public void process(Exchange exchange) throws Exception {
        Cw2Operations operation = determineOperation(exchange);
        CloudWatchClient client = getEndpoint().getCloudWatchClient();

        switch (operation) {
            case putMetricData:
                putMetricData(client, exchange);
                break;
            case listMetrics:
                listMetrics(client, exchange);
                break;
            case describeAlarms:
                describeAlarms(client, exchange);
                break;
            case describeAlarmsForMetric:
                describeAlarmsForMetric(client, exchange);
                break;
            default:
                throw new IllegalArgumentException("Unsupported operation: " + operation);
        }
    }

    public void setPrivateKeyName(String privateKeyName) {
        if (context != null && privateKeyName != null) {
            PrivateKey pk = context.getRegistry().lookupByNameAndType(privateKeyName, PrivateKey.class);
            if (pk != null) {
                setPrivateKey(pk);
            }
        }
        if (privateKeyName != null) {
            this.privateKeyName = privateKeyName;
        }
    }

    public MediaSizeName selectMediaSizeNameISO(String size) {
        if (size.equalsIgnoreCase("iso_a0")) {
            mediaSizeName = MediaSizeName.ISO_A0;
        } else if (size.equalsIgnoreCase("iso_a1")) {
            mediaSizeName = MediaSizeName.ISO_A1;
        } else if (size.equalsIgnoreCase("iso_a2")) {
            mediaSizeName = MediaSizeName.ISO_A2;
        } else if (size.equalsIgnoreCase("iso_a3")) {
            mediaSizeName = MediaSizeName.ISO_A3;
        } else if (size.equalsIgnoreCase("iso_a4")) {
            mediaSizeName = MediaSizeName.ISO_A4;
        } else if (size.equalsIgnoreCase("iso_a5")) {
            mediaSizeName = MediaSizeName.ISO_A5;
        } else if (size.equalsIgnoreCase("iso_a6")) {
            mediaSizeName = MediaSizeName.ISO_A6;
        } else if (size.equalsIgnoreCase("iso_a7")) {
            mediaSizeName = MediaSizeName.ISO_A7;
        } else if (size.equalsIgnoreCase("iso_a8")) {
            mediaSizeName = MediaSizeName.ISO_A8;
        } else if (size.equalsIgnoreCase("iso_a9")) {
            mediaSizeName = MediaSizeName.ISO_A9;
        } else if (size.equalsIgnoreCase("iso_a10")) {
            mediaSizeName = MediaSizeName.ISO_A10;
        } else if (size.equalsIgnoreCase("iso_b0")) {
            mediaSizeName = MediaSizeName.ISO_B0;
        } else if (size.equalsIgnoreCase("iso_b1")) {
            mediaSizeName = MediaSizeName.ISO_B1;
        } else if (size.equalsIgnoreCase("iso_b2")) {
            mediaSizeName = MediaSizeName.ISO_B2;
        } else if (size.equalsIgnoreCase("iso_b3")) {
            mediaSizeName = MediaSizeName.ISO_B3;
        } else if (size.equalsIgnoreCase("iso_b4")) {
            mediaSizeName = MediaSizeName.ISO_B4;
        } else if (size.equalsIgnoreCase("iso_b5")) {
            mediaSizeName = MediaSizeName.ISO_B5;
        } else if (size.equalsIgnoreCase("iso_b6")) {
            mediaSizeName = MediaSizeName.ISO_B6;
        } else if (size.equalsIgnoreCase("iso_b7")) {
            mediaSizeName = MediaSizeName.ISO_B7;
        } else if (size.equalsIgnoreCase("iso_b8")) {
            mediaSizeName = MediaSizeName.ISO_B8;
        } else if (size.equalsIgnoreCase("iso_b9")) {
            mediaSizeName = MediaSizeName.ISO_B9;
        } else if (size.equalsIgnoreCase("iso_b10")) {
            mediaSizeName = MediaSizeName.ISO_B10;
        } else if (size.equalsIgnoreCase("iso_c0")) {
            mediaSizeName = MediaSizeName.ISO_C0;
        } else if (size.equalsIgnoreCase("iso_c1")) {
            mediaSizeName = MediaSizeName.ISO_C1;
        } else if (size.equalsIgnoreCase("iso_c2")) {
            mediaSizeName = MediaSizeName.ISO_C2;
        } else if (size.equalsIgnoreCase("iso_c3")) {
            mediaSizeName = MediaSizeName.ISO_C3;
        } else if (size.equalsIgnoreCase("iso_c4")) {
            mediaSizeName = MediaSizeName.ISO_C4;
        } else if (size.equalsIgnoreCase("iso_c5")) {
            mediaSizeName = MediaSizeName.ISO_C5;
        } else if (size.equalsIgnoreCase("iso_c6")) {
            mediaSizeName = MediaSizeName.ISO_C6;
        }
        return mediaSizeName;
    }

    public FunctionGraphClient initClient() {
        if (functionGraphClient != null) {
            return functionGraphClient;
        }

         
        BasicCredentials auth = new BasicCredentials()
                .withAk(getServiceKeys() != null
                        ? getServiceKeys().getAccessKey()
                        : getAccessKey())
                .withSk(getServiceKeys() != null
                        ? getServiceKeys().getSecretKey()
                        : getSecretKey())
                .withProjectId(getProjectId());

         
        HttpConfig httpConfig = HttpConfig.getDefaultHttpConfig();
        httpConfig.withIgnoreSSLVerification(isIgnoreSslVerification());
        if (ObjectHelper.isNotEmpty(getProxyHost())
                && ObjectHelper.isNotEmpty(getProxyPort())) {
            httpConfig.withProxyHost(getProxyHost())
                    .withProxyPort(getProxyPort());

            if (ObjectHelper.isNotEmpty(getProxyUser())) {
                httpConfig.withProxyUsername(getProxyUser());
                if (ObjectHelper.isNotEmpty(getProxyPassword())) {
                    httpConfig.withProxyPassword(getProxyPassword());
                }
            }
        }

         
        if (ObjectHelper.isNotEmpty(getEndpoint())) {
            return FunctionGraphClient.newBuilder()
                    .withCredential(auth)
                    .withHttpConfig(httpConfig)
                    .withEndpoint(getEndpoint())
                    .build();
        } else {
            return FunctionGraphClient.newBuilder()
                    .withCredential(auth)
                    .withHttpConfig(httpConfig)
                    .withRegion(FunctionGraphRegion.valueOf(getRegion()))
                    .build();
        }
    }

    public <T> Map<String, T> findByTypeWithName(Class<T> type) {
        Map<String, T> result = new HashMap<>();
         
        String keyPrefix = type.getName().replace('$', '/');
        kvClient = consul.keyValueClient();

        List<String> keys;
        try {
            keys = kvClient.getKeys(keyPrefix);
        } catch (ConsulException e) {
            return result;
        }

        if (keys != null) {
            Object obj;

            for (String key : keys) {
                 
                key = key.substring(key.lastIndexOf('/') + 1);
                obj = lookupByName(key.replace('$', '/'));
                if (type.isInstance(obj)) {
                    result.put(key, type.cast(obj));
                }
            }
        }
        return result;
    }

    private void initSecurityProvider() throws Exception {
        Object securityConfiguration = getSecurityConfiguration();
        if (securityConfiguration != null) {
            ServiceLoader<UndertowSecurityProvider> securityProvider = ServiceLoader.load(UndertowSecurityProvider.class);

            Iterator<UndertowSecurityProvider> iter = securityProvider.iterator();
            List<String> providers = new LinkedList();
            while (iter.hasNext()) {
                UndertowSecurityProvider security = iter.next();
                 
                if (security.acceptConfiguration(securityConfiguration, null)) {
                    this.securityProvider = security;
                    LOG.info("Security provider found {}", securityProvider.getClass().getName());
                    break;
                }
                providers.add(security.getClass().getName());
            }
            if (this.securityProvider == null) {
                LOG.info("Security provider for configuration {} not found {}", securityConfiguration, providers);
            }
        }
    }

    private void processGetSuccessfulResults(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
        bulkClient.getSuccessfulResults(jobId, determineHeaders(exchange),
                new StreamResponseCallback() {
                    @Override
                    public void onResponse(
                            InputStream inputStream, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, inputStream, headers, ex, callback);
                    }
                });
    }

    public static int compare(String source, String target) {
        if (source == null || target == null) {
            return 0;
        }
        String s1 = StringHelper.before(source, ".");
        String s2 = StringHelper.after(source, ".");
        if (s1 == null) {
            s1 = StringHelper.before(source, ",");
            s2 = StringHelper.after(source, ",");
        }
        String t1 = StringHelper.before(target, ".");
        String t2 = StringHelper.after(target, ".");
        if (t1 == null) {
            t1 = StringHelper.before(target, ",");
            t2 = StringHelper.after(target, ",");
        }
        String s3 = StringHelper.after(s2, ".");
        if (s3 != null) {
            s2 = StringHelper.before(s2, ".");
        } else {
            s3 = "";
        }
        String t3 = StringHelper.after(t2, ".");
        if (t3 != null) {
            t2 = StringHelper.before(t2, ".");
        } else {
            t3 = "";
        }
         
        if (s1 == null) {
            s1 = source;
        }
        if (s2 == null) {
            s2 = "";
        }
        if (t1 == null) {
            t1 = target;
        }
        if (t2 == null) {
            t2 = "";
        }
         
        if (s1.length() < 2) {
            s1 = "0" + s1;
        }
        if (s2.length() < 2) {
            s2 = "0" + s2;
        }
        if (s2.length() < 2) {
            s2 = "0" + s2;
        }
        if (s3.length() < 2) {
            s3 = "0" + s3;
        }
        if (t1.length() < 2) {
            t1 = "0" + t1;
        }
        if (t2.length() < 2) {
            t2 = "0" + t2;
        }
        if (t3.length() < 2) {
            t3 = "0" + t3;
        }

        String s = s1 + s2 + s3;
        String t = t1 + t2 + t3;
        return s.compareTo(t);
    }

    public <T> T receiveBodyNoWait(String endpointUri, Class<T> type) {
        Object answer;
        Exchange exchange = receiveNoWait(endpointUri);
        try {
            answer = extractResultBody(exchange);
            answer = camelContext.getTypeConverter().convertTo(type, exchange, answer);
        } finally {
            doneUoW(exchange);
        }
        return (T) answer;
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (vertx == null) {
            if (vertxOptions != null) {
                vertx = Vertx.vertx(vertxOptions);
            } else {
                vertx = Vertx.vertx();
            }
            managedVertx = true;
        }
    }

    private static ActiveMQMessage createActiveMQMessage(Exchange exchange) throws JMSException {
        Object body = exchange.getIn().getBody();
        if (body instanceof String) {
            ActiveMQTextMessage answer = new ActiveMQTextMessage();
            answer.setText((String) body);
            return answer;
        } else if (body instanceof Serializable) {
            ActiveMQObjectMessage answer = new ActiveMQObjectMessage();
            answer.setObject((Serializable) body);
            return answer;
        } else {
            return new ActiveMQMessage();
        }

    }

    public int processBatch(Queue<Object> exchanges) {
        final int total = exchanges.size();

        for (int i = 0; i < total && isBatchAllowed(); i++) {
            final Exchange exchange = ObjectHelper.cast(Exchange.class, exchanges.poll());

            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, i);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, i == total - 1);

            pendingExchanges = total - i - 1;

            exchange.getExchangeExtension().addOnCompletion(new Synchronization() {
                @Override
                public void onComplete(Exchange exchange) {
                    LOG.trace("Processing all exchanges completed");
                }

                @Override
                public void onFailure(Exchange exchange) {
                    processRollback(exchange);
                }
            });
             
            AsyncCallback cb = defaultConsumerCallback(exchange, true);
            getAsyncProcessor().process(exchange, cb);
        }

        return total;
    }

    public void createQueryJob(
            QueryJob queryJob, Map<String, List<String>> headers, QueryJobResponseCallback callback) {
        final Request request = getRequest(HttpMethod.POST, queryJobUrl(null), headers);
        try {
            marshalRequest(queryJob, request);
        } catch (SalesforceException e) {
            callback.onResponse(null, Collections.emptyMap(), e);
            return;
        }
        doHttpRequestWithQueryJobResponse(callback, request);
    }

    public static URI createURI(Exchange exchange, String url) throws URISyntaxException {
        URI uri = new URI(url);

         
        String queryString = (String) exchange.getIn().removeHeader(Exchange.REST_HTTP_QUERY);
         
         
        if (queryString == null) {
            queryString = exchange.getIn().getHeader(NettyHttpConstants.HTTP_RAW_QUERY, String.class);
        }
        if (queryString == null) {
            queryString = exchange.getIn().getHeader(NettyHttpConstants.HTTP_QUERY, String.class);
        }
        if (queryString == null) {
             
            queryString = uri.getRawQuery();
        }
        if (queryString != null) {
             
            queryString = UnsafeUriCharactersEncoder.encodeHttpURI(queryString);
            if (ObjectHelper.isEmpty(uri.getPath())) {
                 
                uri = new URI(url + "/");
            }

            uri = URISupport.createURIWithQuery(uri, queryString);
        }
        return uri;
    }

    private void addDelay(SendMessageBatchRequestEntry.Builder request, Exchange exchange) {
        Integer headerValue = exchange.getIn().getHeader(Sqs2Constants.DELAY_HEADER, Integer.class);
        Integer delayValue;
        if (headerValue == null) {
            LOG.trace("Using the config delay");
            delayValue = getEndpoint().getConfiguration().getDelaySeconds();
        } else {
            LOG.trace("Using the header delay");
            delayValue = headerValue;
        }
        LOG.trace("found delay: {}", delayValue);
        if (delayValue != null) {
            request.delaySeconds(delayValue);
        }
    }

    protected void findLocations(Set<String> locations, ClassLoader classLoader) throws IOException {
        Enumeration<URL> resources = classLoader.getResources(LOCATION_PROPERTIES);
        while (resources.hasMoreElements()) {
            URL url = resources.nextElement();
            BufferedReader reader = IOHelper.buffered(new InputStreamReader(url.openStream(), UTF8));
            try {
                while (true) {
                    String line = reader.readLine();
                    if (line == null) {
                        break;
                    }
                    line = line.trim();
                    if (line.startsWith("#") || line.isEmpty()) {
                        continue;
                    }
                    locations.add(line);
                }
            } finally {
                IOHelper.close(reader, null, LOG);
            }
        }
    }

    private void generateComponentConfigurer(
            UriEndpoint uriEndpoint, String scheme, String[] schemes, ComponentModel componentModel,
            ComponentModel parentData) {

        if (!uriEndpoint.generateConfigurer()) {
            return;
        }
         
        if (isFirstScheme(scheme, schemes)) {
            return;
        }
        String pfqn;
        boolean hasSuper;

        Class<?> superClazz = loadClass(componentModel.getJavaType()).getSuperclass();
        if (parentData != null && superClazz.getName().equals(parentData.getJavaType())) {
             
            pfqn = parentData.getJavaType() + "Configurer";
            hasSuper = true;
        } else {
            pfqn = "org.apache.camel.support.component.PropertyConfigurerSupport";
            hasSuper = false;
            parentData = null;
        }
        String psn = pfqn.substring(pfqn.lastIndexOf('.') + 1);
        String fqComponentClassName = componentModel.getJavaType();
        String componentClassName = fqComponentClassName.substring(fqComponentClassName.lastIndexOf('.') + 1);
        String className = componentClassName + "Configurer";
        String packageName = fqComponentClassName.substring(0, fqComponentClassName.lastIndexOf('.'));
        String fqClassName = packageName + "." + className;

        List<ComponentOptionModel> options;
        if (parentData != null) {
            Set<String> parentOptionsNames = parentData.getComponentOptions().stream()
                    .map(ComponentOptionModel::getName).collect(Collectors.toSet());
            options = componentModel.getComponentOptions().stream().filter(o -> !parentOptionsNames.contains(o.getName()))
                    .toList();
        } else {
            options = componentModel.getComponentOptions();
        }
        generatePropertyConfigurer(packageName, className, fqClassName, componentClassName,
                pfqn, psn,
                componentModel.getScheme() + "-component", hasSuper, true,
                options, componentModel);
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        JsonArray array = (JsonArray) root.get("routeGroups");
                        for (int i = 0; i < array.size(); i++) {
                            JsonObject o = (JsonObject) array.get(i);
                            Row row = new Row();
                            row.name = context.getString("name");
                            if ("CamelJBang".equals(row.name)) {
                                row.name = ProcessHelper.extractName(root, ph);
                            }
                            row.pid = Long.toString(ph.pid());
                            row.group = o.getString("group");
                            row.size = o.getInteger("size");
                            row.routeIds = o.getCollection("routeIds");
                            row.state = o.getString("state");
                            row.age = o.getString("uptime");
                            row.uptime = row.age != null ? TimeUtils.toMilliSeconds(row.age) : 0;
                            Map<String, ?> stats = o.getMap("statistics");
                            if (stats != null) {
                                Object load = stats.get("load01");
                                if (load != null) {
                                    row.load01 = load.toString();
                                }
                                load = stats.get("load05");
                                if (load != null) {
                                    row.load05 = load.toString();
                                }
                                load = stats.get("load15");
                                if (load != null) {
                                    row.load15 = load.toString();
                                }
                                Object thp = stats.get("exchangesThroughput");
                                if (thp != null) {
                                    row.throughput = thp.toString();
                                }
                                Object coverage = stats.get("coverage");
                                if (coverage != null) {
                                    row.coverage = coverage.toString();
                                }
                                row.total = stats.get("exchangesTotal").toString();
                                row.inflight = stats.get("exchangesInflight").toString();
                                row.failed = stats.get("exchangesFailed").toString();
                                row.mean = stats.get("meanProcessingTime").toString();
                                if ("-1".equals(row.mean)) {
                                    row.mean = null;
                                }
                                row.max = stats.get("maxProcessingTime").toString();
                                row.min = stats.get("minProcessingTime").toString();
                                Object last = stats.get("lastProcessingTime");
                                if (last != null) {
                                    row.last = last.toString();
                                }
                                last = stats.get("deltaProcessingTime");
                                if (last != null) {
                                    row.delta = last.toString();
                                }
                                last = stats.get("lastCreatedExchangeTimestamp");
                                if (last != null) {
                                    long time = Long.parseLong(last.toString());
                                    row.sinceLastStarted = TimeUtils.printSince(time);
                                }
                                last = stats.get("lastCompletedExchangeTimestamp");
                                if (last != null) {
                                    long time = Long.parseLong(last.toString());
                                    row.sinceLastCompleted = TimeUtils.printSince(time);
                                }
                                last = stats.get("lastFailedExchangeTimestamp");
                                if (last != null) {
                                    long time = Long.parseLong(last.toString());
                                    row.sinceLastFailed = TimeUtils.printSince(time);
                                }
                            }

                            boolean add = true;
                            if (mean > 0 && (row.mean == null || Long.parseLong(row.mean) < mean)) {
                                add = false;
                            }
                            if (limit > 0 && rows.size() >= limit) {
                                add = false;
                            }
                            if (add && filter != null) {
                                boolean match = false;
                                for (String f : filter) {
                                    if (!match) {
                                        match = PatternHelper.matchPattern(row.group, f);
                                    }
                                }
                                if (!match) {
                                    add = false;
                                }
                            }
                            if (add && running) {
                                add = "Started".equals(row.state);
                            }
                            if (add) {
                                rows.add(row);
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printTable(rows);
        }

        return 0;
    }

    private void processGetJob(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        JobInfo jobBody;
        jobBody = exchange.getIn().getBody(JobInfo.class);
        String jobId;
        if (jobBody != null) {
            jobId = jobBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getJob(jobId, determineHeaders(exchange), new BulkApiClient.JobInfoResponseCallback() {
            @Override
            public void onResponse(JobInfo jobInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, jobInfo, headers, ex, callback);
            }
        });
    }

    public List<CamelClusterMember> getMembers() {
        if (leaderSelector == null) {
            return Collections.emptyList();
        }

        try {
            return leaderSelector.getParticipants()
                    .stream()
                    .map(CuratorClusterMember::new)
                    .collect(Collectors.toList());
        } catch (KeeperException.NoNodeException e) {
            LOGGER.debug("Failed to get members because node '{}' does not yet exist (error: '{}')",
                    getFullPath(),
                    e.getMessage());
            return Collections.emptyList();
        } catch (Exception e) {
            throw new RuntimeCamelException(e);
        }
    }

    public Integer doCall() throws Exception {
        List<Long> pids = findPids(name);
        for (long pid : pids) {
            JsonObject root = new JsonObject();
            root.put("action", "gc");
            Path f = getActionFile(Long.toString(pid));
            PathUtils.writeTextSafely(root.toJson(), f);
        }

        return 0;
    }

    private static List<String> getPropertyEnum(Object prop) throws Exception {
        List<String> answer = new ArrayList<>();
        Method m = prop.getClass().getMethod("get_enum");
        List<Object> list = (List<Object>) ObjectHelper.invokeMethod(m, prop);
        if (list != null && !list.isEmpty()) {
            for (var en : list) {
                String t = en.toString();
                t = StringHelper.removeLeadingAndEndingQuotes(t);
                answer.add(t);
            }
        }
        return answer.isEmpty() ? null : answer;
    }

    protected boolean processAsynchronously(
            final Exchange exchange, final AsyncCallback callback, ThrottlingState throttlingState) {
        try {
            if (LOG.isTraceEnabled()) {
                exchange.setProperty(PROPERTY_EXCHANGE_QUEUED_TIME, System.nanoTime());
            }
            exchange.setProperty(PROPERTY_EXCHANGE_STATE, State.ASYNC);
            asyncExecutor.submit(() -> process(exchange, callback));
            return false;
        } catch (final RejectedExecutionException e) {
            if (isCallerRunsWhenRejected()) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("AsyncExecutor is full, rejected exchange will run in the current thread, exchangeId: {}",
                            exchange.getExchangeId());
                }
                exchange.setProperty(PROPERTY_EXCHANGE_STATE, State.ASYNC_REJECTED);
                return process(exchange, callback);
            }
            throw e;
        }
    }

    protected void unInitReplyManager() {
        try {
            if (replyManager != null) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Stopping JmsReplyManager: {} from processing replies from: {}", replyManager,
                            endpoint.getReplyTo() != null ? endpoint.getReplyTo() : "temporary queue");
                }
                ServiceHelper.stopService(replyManager);
            }
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        } finally {
            started.set(false);
        }
    }

    public Byte getByte(final int index) {
        Object returnable = this.get(index);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).byteValue();
    }

    protected void initRouteRefs() throws Exception {
         
        if (getRouteRefs() != null) {
            for (RouteContextRefDefinition ref : getRouteRefs()) {
                List<RouteDefinition> defs = ref.lookupRoutes(getContext());
                for (RouteDefinition def : defs) {
                    LOG.debug("Adding route from {} -> {}", ref, def);
                     
                     
                    getRoutes().add(0, def);
                }
            }
        }
    }

    public Sheets makeClient(
            CamelContext camelContext, String serviceAccountKey, Collection<String> scopes, String applicationName,
            String delegate) {
        if (serviceAccountKey == null) {
            throw new IllegalArgumentException("serviceAccountKey is required to create Google Sheets client.");
        }
        try {
            Credential credential = authorizeServiceAccount(camelContext, serviceAccountKey, delegate, scopes);
            return new Sheets.Builder(transport, jsonFactory, credential).setApplicationName(applicationName).build();
        } catch (Exception e) {
            throw new RuntimeCamelException("Could not create Google Sheets client.", e);
        }
    }

                public void artifactDownloaded(RepositoryEvent event) {
                    if (event.getArtifact() != null) {
                        Artifact a = event.getArtifact();

                        ArtifactRepository ar = event.getRepository();
                        String url = ar instanceof RemoteRepository ? ((RemoteRepository) ar).getUrl() : null;
                        String id = ar != null ? ar.getId() : null;
                        long elapsed = watch.takenAndRestart();
                        String version = a.isSnapshot() ? a.getBaseVersion() : a.getVersion();
                        remoteArtifactDownloadListener.artifactDownloaded(a.getGroupId(), a.getArtifactId(), version,
                                id, url, elapsed);
                    }
                }

    private void setResult(Message message, boolean success, Object result, Object oldValue) {
        message.setHeader(CaffeineConstants.ACTION_SUCCEEDED, success);
        message.setHeader(CaffeineConstants.ACTION_HAS_RESULT, oldValue != null || result != null);

        if (oldValue != null) {
            message.setHeader(CaffeineConstants.OLD_VALUE, oldValue);
        }
        if (result != null) {
            message.setBody(result);
        }
    }

    public static Stream<Path> walk(Path rootDir) {
        try {
            if (Files.isDirectory(rootDir)) {
                return Files.walk(rootDir);
            } else {
                return Stream.empty();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public Long getLongOrDefault(final String key, final long defaultValue) {
        Object returnable;
        if (this.containsKey(key)) {
            returnable = this.get(key);
        } else {
            return defaultValue;
        }
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).longValue();
    }

    public void updateRouteConfigurationsToCamelContext(CamelContext context) throws Exception {
        setCamelContext(context);
        routeConfigurationCollection.setCamelContext(context);
        if (initializedConfiguration.compareAndSet(false, true)) {
            configuration();
        }
        List<RouteConfigurationDefinition> list = getRouteConfigurationCollection().getRouteConfigurations();
        if (!list.isEmpty()) {
             
            for (RouteConfigurationDefinition def : list) {
                context.getCamelContextExtension().getContextPlugin(Model.class)
                        .removeRouteConfiguration(def);
            }
            populateRoutesConfiguration();
        }
    }

        public void fromAdmin(Message message, SessionID sessionID)
                throws FieldNotFound, IncorrectDataFormat, IncorrectTagValue, RejectLogon {
            try {
                dispatch(QuickfixjEventCategory.AdminMessageReceived, sessionID, message);
            } catch (RuntimeException e) {
                throw e;
            } catch (Exception e) {
                rethrowIfType(e, FieldNotFound.class);
                rethrowIfType(e, IncorrectDataFormat.class);
                rethrowIfType(e, IncorrectTagValue.class);
                rethrowIfType(e, RejectLogon.class);
                throw new DispatcherException(e);
            }
        }

                public void artifactDownloading(RepositoryEvent event) {
                    watch.restart();

                    if (event.getArtifact() != null) {
                        Artifact a = event.getArtifact();

                        ArtifactRepository ar = event.getRepository();
                        String url = ar instanceof RemoteRepository ? ((RemoteRepository) ar).getUrl() : null;
                        String id = ar != null ? ar.getId() : null;
                        String version = a.isSnapshot() ? a.getBaseVersion() : a.getVersion();
                        remoteArtifactDownloadListener.artifactDownloading(a.getGroupId(), a.getArtifactId(), version,
                                id, url);
                    }
                }

    protected void doStart() throws Exception {
        super.doStart();

         
        PropertiesComponent pc = camelContext.getPropertiesComponent();
        PropertiesFunction pf = pc.getPropertiesFunction("hashicorp");
        if (pf instanceof HashicorpVaultPropertiesFunction) {
            propertiesFunction = (HashicorpVaultPropertiesFunction) pf;
            LOG.debug("Auto-detecting secrets from properties-function: {}", pf.getName());
        }
         
        HashicorpVaultConfiguration hashicorpVaultConfiguration = getCamelContext().getVaultConfiguration().hashicorp();
        secrets = hashicorpVaultConfiguration.getSecrets();
        if (ObjectHelper.isEmpty(secrets) && propertiesFunction == null) {
            throw new IllegalArgumentException("Secrets must be configured on Hashicorp vault configuration");
        }

        String token = System.getenv(CAMEL_HASHICORP_VAULT_TOKEN_ENV);
        String host = System.getenv(CAMEL_HASHICORP_VAULT_HOST_ENV);
        String port = System.getenv(CAMEL_HASHICORP_VAULT_PORT_ENV);
        String scheme = System.getenv(CAMEL_HASHICORP_VAULT_SCHEME_ENV);
        if (System.getenv(CAMEL_HASHICORP_VAULT_CLOUD_ENV) != null) {
            cloud = Boolean.parseBoolean(System.getenv(CAMEL_HASHICORP_VAULT_CLOUD_ENV));
        }
        namespace = System.getenv(CAMEL_HASHICORP_VAULT_NAMESPACE_ENV);

        if (ObjectHelper.isEmpty(token) && ObjectHelper.isEmpty(host)
                && ObjectHelper.isEmpty(port) && ObjectHelper.isEmpty(scheme) && ObjectHelper.isEmpty(namespace)) {
            if (ObjectHelper.isNotEmpty(hashicorpVaultConfiguration)) {
                token = hashicorpVaultConfiguration.getToken();
                host = hashicorpVaultConfiguration.getHost();
                port = hashicorpVaultConfiguration.getPort();
                scheme = hashicorpVaultConfiguration.getScheme();
                cloud = hashicorpVaultConfiguration.isCloud();
                if (hashicorpVaultConfiguration.isCloud()) {
                    namespace = hashicorpVaultConfiguration.getNamespace();
                }
            }
        }

        if (ObjectHelper.isNotEmpty(token) && ObjectHelper.isNotEmpty(host)
                && ObjectHelper.isNotEmpty(port) && ObjectHelper.isNotEmpty(scheme)) {
            VaultEndpoint vaultEndpoint = new VaultEndpoint();
            vaultEndpoint.setHost(host);
            vaultEndpoint.setPort(Integer.parseInt(port));
            vaultEndpoint.setScheme(scheme);

            client = new VaultTemplate(
                    vaultEndpoint,
                    new TokenAuthentication(token));
        } else {
            throw new RuntimeCamelException(
                    "Using the Hashicorp Vault Secrets Refresh Task requires setting Token, Host, port and scheme properties");
        }
    }

    protected void maybeDisconnectOnDone(Exchange exchange) throws InterruptedException {
        if (session == null) {
            return;
        }

         
        Boolean close;
        if (ExchangeHelper.isOutCapable(exchange)) {
            close = exchange.getOut().getHeader(MinaConstants.MINA_CLOSE_SESSION_WHEN_COMPLETE, Boolean.class);
        } else {
            close = exchange.getIn().getHeader(MinaConstants.MINA_CLOSE_SESSION_WHEN_COMPLETE, Boolean.class);
        }

         
        boolean disconnect = getEndpoint().getConfiguration().isDisconnect();
        if (close != null) {
            disconnect = close;
        }
        if (disconnect) {
            LOG.debug("Closing session when complete at address: {}", address);
            closeSessionIfNeededAndAwaitCloseInHandler(session);
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.cosmosdb.changes");

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                "org.apache.camel.event.azure.cosmosdb.changefeed");

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, "org.apache.camel.event.azure.cosmosdb.changefeed");
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.TEXT_PLAIN_MIME_TYPE);
    }

    public static boolean updateResource(BuildContext buildContext, Path out, String data) {
        try {
            if (FileUtil.updateFile(out, data)) {
                refresh(buildContext, out);
                return true;
            }
        } catch (IOException e) {
            throw new IOError(e);
        }
        return false;
    }

    protected String resolvePropertyPlaceholders(String str) {
        try {
            if (getCamelContext() != null) {
                return getCamelContext().resolvePropertyPlaceholders(str);
            } else {
                return str;
            }
        } catch (Exception ex) {
            throw RuntimeCamelException.wrapRuntimeCamelException(ex);
        }
    }

    private String getUri(Row r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    private String getAlgorithmName(String algorithm) {
        try {
            return PQCSignatureAlgorithms.valueOf(algorithm).getAlgorithm();
        } catch (IllegalArgumentException e1) {
            try {
                return PQCKeyEncapsulationAlgorithms.valueOf(algorithm).getAlgorithm();
            } catch (IllegalArgumentException e2) {
                return algorithm;
            }
        }
    }

    private int ensureBuffering(int size) throws IOException {
        if (size < bpos) {
            return bpos;
        }
         
        try {

             
            if (XMLStreamConstants.START_DOCUMENT == reader.getEventType()) {
                writer.writeStartDocument("utf-8", "1.0");
            }
            if (chunk.size() < buffer.length) {
                while (reader.hasNext()) {
                    int code = reader.next();
                    switch (code) {
                        case XMLStreamConstants.END_DOCUMENT:
                            writer.writeEndDocument();
                            break;
                        case XMLStreamConstants.START_ELEMENT:
                            QName qname = reader.getName();
                            writer.writeStartElement(qname.getPrefix(), qname.getLocalPart(), qname.getNamespaceURI());
                            for (int i = 0; i < reader.getAttributeCount(); i++) {
                                writer.writeAttribute(
                                        reader.getAttributePrefix(i), reader.getAttributeNamespace(i),
                                        reader.getAttributeLocalName(i),
                                        reader.getAttributeValue(i));
                            }
                            for (int i = 0; i < reader.getNamespaceCount(); i++) {
                                writer.writeNamespace(reader.getNamespacePrefix(i), reader.getNamespaceURI(i));
                            }
                            break;
                        case XMLStreamConstants.END_ELEMENT:
                            writer.writeEndElement();
                            break;
                        case XMLStreamConstants.CHARACTERS:
                            writer.writeCharacters(reader.getText());
                            break;
                        case XMLStreamConstants.COMMENT:
                            writer.writeComment(reader.getText());
                            break;
                        case XMLStreamConstants.CDATA:
                            writer.writeCData(reader.getText());
                            break;
                        default:
                            break;
                    }

                     
                    final int csize = buffer.length - bpos;
                    if (chunk.size() > csize) {
                        System.arraycopy(chunk.getCharArray(), 0, buffer, bpos, csize);
                        bpos = buffer.length;
                        chunk.trim(csize, 0);
                        return buffer.length;
                    }
                }
            }
            final int csize = Math.min(chunk.size(), buffer.length - bpos);
            if (csize > 0) {
                System.arraycopy(chunk.getCharArray(), 0, buffer, bpos, csize);
                bpos += csize;
                chunk.trim(csize, 0);
                return bpos;
            } else {
                return bpos > 0 ? bpos : -1;
            }
        } catch (XMLStreamException e) {
            throw new IOException(e);
        }
    }

    protected void doCommit(Exchange exchange, String operation) throws GitAPIException {
        String commitMessage = null;
        String username = null;
        String email = null;
        if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_COMMIT_MESSAGE))) {
            commitMessage = exchange.getIn().getHeader(GitConstants.GIT_COMMIT_MESSAGE, String.class);
        } else {
            throw new IllegalArgumentException("Commit message must be specified to execute " + operation);
        }
        if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_COMMIT_USERNAME))
                && ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_COMMIT_EMAIL))) {
            username = exchange.getIn().getHeader(GitConstants.GIT_COMMIT_USERNAME, String.class);
            email = exchange.getIn().getHeader(GitConstants.GIT_COMMIT_EMAIL, String.class);
        }
        boolean allowEmpty = endpoint.isAllowEmpty();
        if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(GitConstants.GIT_ALLOW_EMPTY))) {
            allowEmpty = exchange.getIn().getHeader(GitConstants.GIT_ALLOW_EMPTY, Boolean.class);
        }

        try {
            if (ObjectHelper.isNotEmpty(endpoint.getBranchName())) {
                git.checkout().setCreateBranch(false).setName(endpoint.getBranchName()).call();
            }
            if (ObjectHelper.isNotEmpty(username) && ObjectHelper.isNotEmpty(email)) {
                git.commit().setAllowEmpty(allowEmpty).setCommitter(username, email).setMessage(commitMessage).call();
            } else {
                git.commit().setAllowEmpty(allowEmpty).setMessage(commitMessage).call();
            }
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
    }

    private <T> T getRequiredHeader(
            Exchange exchange,
            String headerName,
            Class<T> headerType,
            Supplier<T> configurationValue,
            String errorMessage) {
        T value = exchange.getIn().getHeader(headerName, headerType);
        if (ObjectHelper.isEmpty(value)) {
            value = configurationValue.get();
        }
        if (ObjectHelper.isEmpty(value)) {
            throw new IllegalArgumentException(errorMessage);
        }
        return value;
    }

    private ZendeskApiCollection() {
        final Map<String, String> aliases = new HashMap<>();
        final Map<ZendeskApiName, ApiMethodHelper<? extends ApiMethod>> apiHelpers = new EnumMap<>(ZendeskApiName.class);
        final Map<Class<? extends ApiMethod>, ZendeskApiName> apiMethods = new HashMap<>();

        List<String> nullableArgs;

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(ZendeskApiName.DEFAULT, new ApiMethodHelper<>(ZendeskApiMethod.class, aliases, nullableArgs));
        apiMethods.put(ZendeskApiMethod.class, ZendeskApiName.DEFAULT);

        setApiHelpers(apiHelpers);
        setApiMethods(apiMethods);
    }

    private boolean hasFailed(Exchange exchange) {
        if (exchange == null) {
            return false;
        }

        boolean answer = false;

        if (exchange.getException() != null) {
            if (throttledExceptions == null || throttledExceptions.isEmpty()) {
                 
                 
                answer = true;
            } else {
                for (Class<?> exception : throttledExceptions) {
                     
                    if (exchange.getException(exception) != null) {
                        answer = true;
                        break;
                    }
                }
            }
        }

        if (LOG.isDebugEnabled()) {
            String exceptionName
                    = exchange.getException() == null ? "none" : exchange.getException().getClass().getSimpleName();
            LOG.debug("hasFailed ({}) with Throttled Exception: {} for exchangeId: {}", answer, exceptionName,
                    exchange.getExchangeId());
        }
        return answer;
    }

    public Integer doCall() throws Exception {
        List<Long> pids = findPids(name);

        for (long pid : pids) {
            JsonObject root = new JsonObject();
            root.put("action", "processor");
            root.put("id", id);
            Path f = getActionFile(Long.toString(pid));
            onAction(root);
            PathUtils.writeTextSafely(root.toJson(), f);
        }

        return 0;
    }

    protected void configureDataGramCodecFactory(
            final String type, final IoService service, final MinaConfiguration configuration) {
        ProtocolCodecFactory codecFactory = configuration.getCodec();
        if (codecFactory == null) {
            codecFactory = new MinaUdpProtocolCodecFactory(this.getEndpoint().getCamelContext());

            if (LOG.isDebugEnabled()) {
                LOG.debug("{}: Using CodecFactory: {}", type, codecFactory);
            }
        }

        addCodecFactory(service, codecFactory);
    }

    public void close() {
        if (listenerThread != null) {
            lock.lock();
            try {
                try {
                    listenerThread.serverSocket.close();
                } catch (IOException e) {
                    LOG.info(e.getMessage(), e);
                } finally {
                    listenerThread = null;
                }
            } finally {
                lock.unlock();
            }
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    private ExecStartCmd executeExecStartRequest(DockerClient client, Message message) {

        LOG.debug("Executing Docker Exec Start Request");

        String execId = DockerHelper.getProperty(DockerConstants.DOCKER_EXEC_ID, configuration, message, String.class);

        ObjectHelper.notNull(execId, "Exec ID must be specified");

        ExecStartCmd execStartCmd = client.execStartCmd(execId);

        Boolean detach = DockerHelper.getProperty(DockerConstants.DOCKER_DETACH, configuration, message, Boolean.class);

        if (detach != null) {
            execStartCmd.withDetach(detach);
        }

        Boolean tty = DockerHelper.getProperty(DockerConstants.DOCKER_TTY, configuration, message, Boolean.class);

        if (tty != null) {
            execStartCmd.withTty(tty);
        }

        return execStartCmd;

    }

    public AS2Configuration getEndpointConfiguration(AS2ApiName apiName) {
        AS2Configuration result = null;
        switch (apiName) {
            case CLIENT:
                result = new AS2ClientManagerEndpointConfiguration();
                break;
            case SERVER:
                result = new AS2ServerManagerEndpointConfiguration();
                break;
            case RECEIPT:
                result = new AS2AsyncMDNServerManagerEndpointConfiguration();
                break;
        }
        return result;
    }

    private RemoteFile<SftpRemoteFile> asRemoteFile(
            String absolutePath, String absoluteFilePath, SftpRemoteFile file, String charset) {
        RemoteFile<SftpRemoteFile> answer = new RemoteFile<>();

        answer.setCharset(charset);
        answer.setEndpointPath(endpointPath);
        answer.setFile(file);
        answer.setFileNameOnly(file.getFilename());
        answer.setFileLength(file.getFileLength());
        answer.setLastModified(file.getLastModified());
        answer.setHostname(((RemoteFileConfiguration) endpoint.getConfiguration()).getHost());
        answer.setDirectory(file.isDirectory());

         
        boolean absolute = FileUtil.hasLeadingSeparator(absolutePath);
        answer.setAbsolute(absolute);
        answer.setAbsoluteFilePath(absoluteFilePath);

         
        String relativePath = StringHelper.after(absoluteFilePath, endpointPath);
         
        relativePath = FileUtil.stripLeadingSeparator(relativePath);
        answer.setRelativeFilePath(relativePath);

         
        answer.setFileName(answer.getRelativeFilePath());

        return answer;
    }

    public static JsonObject asJsonObject(PojoBeanModel model) {
        JsonObject obj = new JsonObject();
        baseToJson(model, obj);
        artifactToJson(model, obj);
        obj.entrySet().removeIf(e -> e.getValue() == null);
        JsonObject wrapper = new JsonObject();
        wrapper.put("bean", obj);
        wrapper.put("properties", asJsonObject(model.getOptions()));
        return wrapper;
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer target = (org.apache.camel.component.consul.endpoint.ConsulCoordinatesProducer) obj;
        switch (key) {
        case "datacenters":
        case "DATACENTERS": target.datacenters(exchange.getMessage()); return null;
        case "nodes":
        case "NODES": target.nodes(exchange.getMessage()); return null;
        default: return null;
        }
    }

    public FluentProducerTemplate withHeaders(Map<String, Object> headers) {
        DefaultFluentProducerTemplate clone = checkCloned();

        if (clone.processorSupplier != null) {
            throw new IllegalArgumentException("Cannot use both withHeaders and withProcessor with FluentProducerTemplate");
        }

        Map<String, Object> map = clone.headers;
        if (map == null) {
            map = new LinkedHashMap<>();
            clone.headers = map;
        }
        map.putAll(headers);
        return clone;
    }

    protected void doStart() throws Exception {
         
         
        boolean startScheduler = isStartScheduler();
        setStartScheduler(false);
        try {
            super.doStart();
            if (endpoint.isAutoCreate() && hasStartingDirectory()) {
                String dir = endpoint.getConfiguration().getDirectory();
                LOG.debug("Auto creating directory: {}", dir);
                try {
                    connectIfNecessary();
                    operations.buildDirectory(dir, true);
                } catch (GenericFileOperationFailedException e) {
                     
                    LOG.warn(
                            "Error auto creating directory: " + dir + " due " + e.getMessage() + ". This exception is ignored.",
                            e);
                }
            }
        } finally {
            if (startScheduler) {
                setStartScheduler(true);
                startScheduler();
            }
        }
    }

    public Exchange get(final CamelContext camelContext, final String key) {
        Exchange answer = null;

        try {
            byte[] lDbKey = keyBuilder(repositoryName, key);
            LOG.trace("Getting key index {}", key);
            byte[] rc = levelDBFile.getDb().get(lDbKey);

            if (rc != null) {
                answer = codec().unmarshallExchange(camelContext, rc);
            }
        } catch (IOException e) {
            throw new RuntimeCamelException("Error getting key " + key + " from repository " + repositoryName, e);
        }

        LOG.debug("Getting key  [{}] -> {}", key, answer);
        return answer;
    }

    public ProcessResponse cancelProcessInstance(ProcessRequest processMessage) {
        ProcessResponse resultMessage = new ProcessResponse();
        resultMessage.setProcessInstanceKey(processMessage.getProcessInstanceKey());

        try {
            GatewayGrpc.GatewayBlockingStub stub = GatewayGrpc.newBlockingStub(managedChannel);
            GatewayOuterClass.CancelProcessInstanceResponse cancelProcessInstanceResponse
                    = stub.cancelProcessInstance(GatewayOuterClass.CancelProcessInstanceRequest.newBuilder()
                            .setProcessInstanceKey(processMessage.getProcessInstanceKey())
                            .build());

            resultMessage.setSuccess(true);
        } catch (StatusRuntimeException exception) {
            LOG.error(String.format("Cannot cancel process instance %s", processMessage.getProcessId()), exception);
            resultMessage.setErrorMessage(exception.getMessage());
            resultMessage.setErrorCode(exception.getStatus().toString());
            resultMessage.setSuccess(false);
        }

        return resultMessage;
    }

    private HttpServerChannelHandler getHandler(HttpRequest request, String method) {
        HttpServerChannelHandler answer = null;

         
        for (final HttpServerChannelHandler handler : consumers) {
            NettyHttpConsumer consumer = handler.getConsumer();

            final NettyHttpConfiguration configuration = consumer.getConfiguration();
            if (configuration.isHttpProxy()) {
                return handler;
            }
        }

         
        if (method == null) {
            return null;
        }

        String path = request.uri();
        int idx = path.indexOf(token);
        if (idx > -1) {
            path = path.substring(idx + len);
        }
         
        path = pathAsKey(path);

        List<RestConsumerContextPathMatcher.ConsumerPath<HttpServerChannelHandler>> paths = new ArrayList<>();
        for (final HttpServerChannelHandler handler : consumers) {
            paths.add(new HttpRestConsumerPath(handler));
        }

        RestConsumerContextPathMatcher.ConsumerPath<HttpServerChannelHandler> best
                = RestConsumerContextPathMatcher.matchBestPath(method, path, paths);
        if (best != null) {
            answer = best.getConsumer();
        }

         
        List<HttpServerChannelHandler> candidates = new ArrayList<>();
        if (answer == null) {
            for (final HttpServerChannelHandler handler : consumers) {
                NettyHttpConsumer consumer = handler.getConsumer();

                String consumerPath = consumer.getConfiguration().getPath();
                boolean matchOnUriPrefix = consumer.getEndpoint().getConfiguration().isMatchOnUriPrefix();
                 
                if (RestConsumerContextPathMatcher.matchPath(path, consumerPath, matchOnUriPrefix)) {
                    candidates.add(handler);
                }
            }
        }

         
        candidates = candidates.stream()
                .filter(c -> matchRestMethod(method, c.getConsumer().getEndpoint().getHttpMethodRestrict()))
                .collect(Collectors.toList());
        if (candidates.size() == 1) {
            answer = candidates.get(0);
        }

        return answer;
    }

    protected String populateContentOnMimeMessage(MimeMessage part, MailConfiguration configuration, Exchange exchange)
            throws MessagingException, IOException {

        String contentType = determineContentType(configuration, exchange);

        LOG.trace("Using Content-Type {} for MimeMessage: {}", contentType, part);

        String body = exchange.getIn().getBody(String.class);
        if (body == null) {
            body = "";
        }

         
        DataSource ds = new ByteArrayDataSource(body, contentType);
        part.setDataHandler(new DataHandler(ds));

         
        part.setHeader("Content-Type", contentType);

        return contentType;
    }

    public OutputLengthGuardrail(int maxChars, int minChars, boolean truncateOnOverflow) {
        if (maxChars <= 0) {
            throw new IllegalArgumentException("maxChars must be positive");
        }
        if (minChars < 0) {
            throw new IllegalArgumentException("minChars cannot be negative");
        }
        if (minChars > maxChars) {
            throw new IllegalArgumentException("minChars cannot exceed maxChars");
        }
        this.maxChars = maxChars;
        this.minChars = minChars;
        this.truncateOnOverflow = truncateOnOverflow;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        String[] parts = remaining.split(":");

        if (parts.length < 2) {
            throw new IllegalArgumentException("Google BigQuery Endpoint format \"projectId:datasetId:tableName\"");
        }

        GoogleBigQueryConfiguration conf = configuration != null ? configuration.copy() : new GoogleBigQueryConfiguration();
        conf.parseRemaining(remaining);

        GoogleBigQueryEndpoint endpoint = new GoogleBigQueryEndpoint(uri, this, conf);
        setProperties(endpoint, parameters);
        return endpoint;
    }

    protected void setRegisterDeliveryReceiptFlag(SubmitMulti[] submitMulties, Message message) {
        byte specifiedDeliveryFlag = getRegisterDeliveryFlag(message);
        byte flag;
        if (getRequestsSingleDLR(message)) {
             
            flag = SMSCDeliveryReceipt.DEFAULT.value();
        } else {
            flag = specifiedDeliveryFlag;
        }

        for (int i = 0; i < submitMulties.length - 1; i++) {
            submitMulties[i].setRegisteredDelivery(flag);
        }
        submitMulties[submitMulties.length - 1].setRegisteredDelivery(specifiedDeliveryFlag);
    }

        int asNum() {
            switch (this) {
                case LE:
                    return ComparisonTerm.LE;
                case LT:
                    return ComparisonTerm.LT;
                case EQ:
                    return ComparisonTerm.EQ;
                case NE:
                    return ComparisonTerm.NE;
                case GT:
                    return ComparisonTerm.GT;
                case GE:
                    return ComparisonTerm.GE;
                default:
                    throw new IllegalArgumentException("Unknown comparison " + this);
            }
        }

    public Consumer createConsumer(Processor processor) throws Exception {
        validate();
        JpaConsumer consumer = new JpaConsumer(this, processor);
        consumer.setMaxMessagesPerPoll(getMaxMessagesPerPoll());
        consumer.setQuery(getQuery());
        consumer.setNamedQuery(getNamedQuery());
        consumer.setNativeQuery(getNativeQuery());
        consumer.setLockModeType(getLockModeType());
        consumer.setParameters(getParameters());
        consumer.setResultClass(getResultClass());
        consumer.setTransacted(isTransacted());
        consumer.setSkipLockedEntity(isSkipLockedEntity());
        consumer.setDeleteHandler(getDeleteHandler());
        consumer.setPreDeleteHandler(getPreDeleteHandler());
        configureConsumer(consumer);
        return consumer;
    }

    public RestDefinition enableNoContentResponse(boolean enableNoContentResponse) {
        if (getVerbs().isEmpty()) {
            this.enableNoContentResponse = Boolean.toString(enableNoContentResponse);
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.setEnableNoContentResponse(Boolean.toString(enableNoContentResponse));
        }

        return this;
    }

    public int processBatch(Queue<Object> exchanges) throws Exception {
        int total = exchanges.size();

        for (int index = 0; index < total && isBatchAllowed(); index++) {
             
            final Exchange exchange = ObjectHelper.cast(Exchange.class, exchanges.poll());
             
            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, index);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, index == total - 1);

             
            pendingExchanges = total - index - 1;

             
             
            if (!getEndpoint().getConfiguration().isBatchDelete()) {
                exchange.getExchangeExtension().addOnCompletion(new Synchronization() {
                    final String reservationId
                            = ExchangeHelper.getMandatoryHeader(exchange, IronMQConstants.MESSAGE_RESERVATION_ID, String.class);
                    final String messageid
                            = ExchangeHelper.getMandatoryHeader(exchange, IronMQConstants.MESSAGE_ID, String.class);

                    public void onComplete(Exchange exchange) {
                        processCommit(exchange, messageid, reservationId);
                    }

                    public void onFailure(Exchange exchange) {
                        processRollback(exchange);
                    }

                    @Override
                    public String toString() {
                        return "IronMQConsumerOnCompletion";
                    }
                });
            }

            LOG.trace("Processing exchange [{}]...", exchange);

            getProcessor().process(exchange);
        }

        return total;
    }

    private void createClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).clients().get(clientUuid).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Client role created successfully");
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.storage.blob.getBlob");

        if (message.getHeaders().containsKey(BlobConstants.E_TAG)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.storage.blob." + message.getHeader(BlobConstants.E_TAG, String.class));
        }

        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(BlobConstants.BLOB_NAME, String.class));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvents.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    private Group messageToGroup(Message message) {
        Group group = message.getBody(Group.class);

        if (group == null) {
            Map headers = message.getHeaders();
            GroupBuilder builder = Builders.group();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            builder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(KeystoneConstants.DOMAIN_ID)) {
                builder.domainId(message.getHeader(KeystoneConstants.DOMAIN_ID, String.class));
            }

            if (headers.containsKey(KeystoneConstants.DESCRIPTION)) {
                builder.description(message.getHeader(KeystoneConstants.DESCRIPTION, String.class));
            }

            group = builder.build();
        }
        return group;
    }

    private JsonObject asJsonObject(BeanPojoModel model) {
        JsonObject jo = new JsonObject();
         
        jo.put("kind", "bean");
        jo.put("name", model.getName());
        jo.put("javaType", model.getClassName());
        if (model.getInterfaceName() != null) {
            jo.put("interfaceType", model.getInterfaceName());
        }
        jo.put("title", asTitle(model.getName()));
        if (model.getDescription() != null) {
            jo.put("description", model.getDescription());
        }
        jo.put("deprecated", model.isDeprecated());
        jo.put("groupId", project.getGroupId());
        jo.put("artifactId", project.getArtifactId());
        jo.put("version", project.getVersion());

        if (!model.getOptions().isEmpty()) {
            JsonObject options = JsonMapper.asJsonObject(model.getOptions());
            jo.put("properties", options);
        }

        JsonObject root = new JsonObject();
        root.put("bean", jo);
        return root;
    }

    public static Predicate isGreaterThan(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return false;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceCompare(exchange.getContext().getTypeConverter(), leftValue, rightValue) > 0;
            }

            protected String getOperationText() {
                return ">";
            }
        };
    }

    public Map<String, Object> endpointProperties(Exchange exchange, String uri) throws Exception {
        Map<String, Object> properties;
         
        Map<String, Object> map = URISupport.parseQuery(URISupport.extractQuery(uri));
        if (map != null && !map.isEmpty() && isLenientProperties()) {
            if (resolveRawParameterValues()) {
                 
                 
                 
                RawParameterHelper.resolveRawParameterValues(exchange.getContext(), map);
            }
             
            properties = new LinkedHashMap<>();
            map.forEach((k, v) -> {
                boolean accept = knownProperties.contains(k);
                 
                 
                if (!accept && !knownPrefixes.isEmpty()) {
                    accept = knownPrefixes.values().stream().anyMatch(k::startsWith);
                }
                if (accept) {
                    properties.put(k, v);
                }
            });
        } else {
            properties = map;
        }

        return properties;
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumOracleComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumOracleComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumOracleComponent) component).setConfiguration((org.apache.camel.component.debezium.oracle.configuration.OracleConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumOracleComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumOracleComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumOracleComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumOracleComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "archiveDestinationName": getOrCreateConfiguration((DebeziumOracleComponent) component).setArchiveDestinationName((java.lang.String) value); return true;
            case "archiveLogHours": getOrCreateConfiguration((DebeziumOracleComponent) component).setArchiveLogHours((long) value); return true;
            case "binaryHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setBinaryHandlingMode((java.lang.String) value); return true;
            case "columnExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setColumnExcludeList((java.lang.String) value); return true;
            case "columnIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setColumnIncludeList((java.lang.String) value); return true;
            case "columnPropagateSourceType": getOrCreateConfiguration((DebeziumOracleComponent) component).setColumnPropagateSourceType((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumOracleComponent) component).setConverters((java.lang.String) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumOracleComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumOracleComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseConnectionAdapter": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseConnectionAdapter((java.lang.String) value); return true;
            case "databaseDbname": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseDbname((java.lang.String) value); return true;
            case "databaseHostname": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseHostname((java.lang.String) value); return true;
            case "databaseOutServerName": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseOutServerName((java.lang.String) value); return true;
            case "databasePassword": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabasePassword((java.lang.String) value); return true;
            case "databasePdbName": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabasePdbName((java.lang.String) value); return true;
            case "databasePort": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabasePort((int) value); return true;
            case "databaseQueryTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseQueryTimeoutMs((int) value); return true;
            case "databaseUrl": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseUrl((java.lang.String) value); return true;
            case "databaseUser": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatabaseUser((java.lang.String) value); return true;
            case "datatypePropagateSourceType": getOrCreateConfiguration((DebeziumOracleComponent) component).setDatatypePropagateSourceType((java.lang.String) value); return true;
            case "decimalHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setDecimalHandlingMode((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumOracleComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumOracleComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumOracleComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumOracleComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatActionQuery": getOrCreateConfiguration((DebeziumOracleComponent) component).setHeartbeatActionQuery((java.lang.String) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumOracleComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "includeSchemaChanges": getOrCreateConfiguration((DebeziumOracleComponent) component).setIncludeSchemaChanges((boolean) value); return true;
            case "includeSchemaComments": getOrCreateConfiguration((DebeziumOracleComponent) component).setIncludeSchemaComments((boolean) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "intervalHandlingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setIntervalHandlingMode((java.lang.String) value); return true;
            case "legacyDecimalHandlingStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setLegacyDecimalHandlingStrategy((boolean) value); return true;
            case "lobEnabled": getOrCreateConfiguration((DebeziumOracleComponent) component).setLobEnabled((boolean) value); return true;
            case "logMiningArchiveLogOnlyMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningArchiveLogOnlyMode((boolean) value); return true;
            case "logMiningArchiveLogOnlyScnPollIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningArchiveLogOnlyScnPollIntervalMs((long) value); return true;
            case "logMiningBatchSizeDefault": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeDefault((long) value); return true;
            case "logMiningBatchSizeIncrement": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeIncrement((long) value); return true;
            case "logMiningBatchSizeMax": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeMax((long) value); return true;
            case "logMiningBatchSizeMin": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBatchSizeMin((long) value); return true;
            case "logMiningBufferDropOnStop": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferDropOnStop((boolean) value); return true;
            case "logMiningBufferEhcacheEventsConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheEventsConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheGlobalConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheGlobalConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheProcessedtransactionsConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheProcessedtransactionsConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheSchemachangesConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheSchemachangesConfig((java.lang.String) value); return true;
            case "logMiningBufferEhcacheTransactionsConfig": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferEhcacheTransactionsConfig((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheEvents": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheEvents((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheGlobal": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheGlobal((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheProcessedTransactions": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheProcessedTransactions((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheSchemaChanges": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheSchemaChanges((java.lang.String) value); return true;
            case "logMiningBufferInfinispanCacheTransactions": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferInfinispanCacheTransactions((java.lang.String) value); return true;
            case "logMiningBufferTransactionEventsThreshold": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferTransactionEventsThreshold((long) value); return true;
            case "logMiningBufferType": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningBufferType((java.lang.String) value); return true;
            case "logMiningClientidExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningClientidExcludeList((java.lang.String) value); return true;
            case "logMiningClientidIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningClientidIncludeList((java.lang.String) value); return true;
            case "logMiningFlushTableName": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningFlushTableName((java.lang.String) value); return true;
            case "logMiningIncludeRedoSql": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningIncludeRedoSql((boolean) value); return true;
            case "logMiningPathDictionary": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningPathDictionary((java.lang.String) value); return true;
            case "logMiningQueryFilterMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningQueryFilterMode((java.lang.String) value); return true;
            case "logMiningReadonlyHostname": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningReadonlyHostname((java.lang.String) value); return true;
            case "logMiningRestartConnection": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningRestartConnection((boolean) value); return true;
            case "logMiningScnGapDetectionGapSizeMin": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningScnGapDetectionGapSizeMin((long) value); return true;
            case "logMiningScnGapDetectionTimeIntervalMaxMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningScnGapDetectionTimeIntervalMaxMs((long) value); return true;
            case "logMiningSessionMaxMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSessionMaxMs((long) value); return true;
            case "logMiningSleepTimeDefaultMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeDefaultMs((long) value); return true;
            case "logMiningSleepTimeIncrementMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeIncrementMs((long) value); return true;
            case "logMiningSleepTimeMaxMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeMaxMs((long) value); return true;
            case "logMiningSleepTimeMinMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningSleepTimeMinMs((long) value); return true;
            case "logMiningStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningStrategy((java.lang.String) value); return true;
            case "logMiningTransactionRetentionMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningTransactionRetentionMs((long) value); return true;
            case "logMiningUsernameExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningUsernameExcludeList((java.lang.String) value); return true;
            case "logMiningUsernameIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setLogMiningUsernameIncludeList((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumOracleComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "messageKeyColumns": getOrCreateConfiguration((DebeziumOracleComponent) component).setMessageKeyColumns((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumOracleComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumOracleComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "openlogreplicatorHost": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlogreplicatorHost((java.lang.String) value); return true;
            case "openlogreplicatorPort": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlogreplicatorPort((int) value); return true;
            case "openlogreplicatorSource": getOrCreateConfiguration((DebeziumOracleComponent) component).setOpenlogreplicatorSource((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumOracleComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumOracleComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setQueryFetchSize((int) value); return true;
            case "racNodes": getOrCreateConfiguration((DebeziumOracleComponent) component).setRacNodes((java.lang.String) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternal": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternal((java.lang.String) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaHistoryInternalSkipUnparseableDdl": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalSkipUnparseableDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedDatabasesDdl": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalStoreOnlyCapturedDatabasesDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedTablesDdl": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaHistoryInternalStoreOnlyCapturedTablesDdl((boolean) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumOracleComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumOracleComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumOracleComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotDatabaseErrorsMaxRetries": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotDatabaseErrorsMaxRetries((int) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotLockingMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotLockingMode((java.lang.String) value); return true;
            case "snapshotLockTimeoutMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotLockTimeoutMs((long) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "snapshotSelectStatementOverrides": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotSelectStatementOverrides((java.lang.String) value); return true;
            case "snapshotTablesOrderByRowCount": getOrCreateConfiguration((DebeziumOracleComponent) component).setSnapshotTablesOrderByRowCount((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumOracleComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumOracleComponent) component).setStreamingDelayMs((long) value); return true;
            case "tableExcludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setTableExcludeList((java.lang.String) value); return true;
            case "tableIncludeList": getOrCreateConfiguration((DebeziumOracleComponent) component).setTableIncludeList((java.lang.String) value); return true;
            case "timePrecisionMode": getOrCreateConfiguration((DebeziumOracleComponent) component).setTimePrecisionMode((java.lang.String) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumOracleComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumOracleComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumOracleComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumOracleComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            case "unavailableValuePlaceholder": getOrCreateConfiguration((DebeziumOracleComponent) component).setUnavailableValuePlaceholder((java.lang.String) value); return true;
            default: return false;
            }
        }

    public void afterPropertiesSet() {
        if (ObjectHelper.isEmpty(loggerId)) {
            log = LoggerFactory.getLogger(this.getClass().getName());
        } else {
            log = LoggerFactory.getLogger(loggerId);
        }

         
         
         

        log.trace("Project ID: {}", this.projectId);
        log.trace("Destination Name: {}", this.destinationName);
    }

    Consumer doCreateConsumer(
            CamelContext camelContext, Processor processor, String verb, String basePath, String uriTemplate,
            RestConfiguration configuration, Map<String, Object> parameters, boolean api)
            throws Exception {

        String path = basePath;
        if (uriTemplate != null) {
             
            if (uriTemplate.startsWith("/")) {
                path = path + uriTemplate;
            } else {
                path = path + "/" + uriTemplate;
            }
        }
        path = FileUtil.stripLeadingSeparator(path);

        String scheme = "http";
        String host = "";
        int port = 0;

         
        RestConfiguration config = configuration;
        if (config == null) {
            config = CamelContextHelper.getRestConfiguration(getCamelContext(), "jetty");
        }

        if (config.getScheme() != null) {
            scheme = config.getScheme();
        }
        if (config.getHost() != null) {
            host = config.getHost();
        }
        int num = config.getPort();
        if (num > 0) {
            port = num;
        }

         
        String contextPath = config.getContextPath();
        if (ObjectHelper.isNotEmpty(contextPath)) {
            contextPath = FileUtil.stripTrailingSeparator(contextPath);
            contextPath = FileUtil.stripLeadingSeparator(contextPath);
            if (ObjectHelper.isNotEmpty(contextPath)) {
                path = contextPath + "/" + path;
            }
        }

         
        if (ObjectHelper.isEmpty(host)) {
            host = RestComponentHelper.resolveRestHostName(host, config);
        }

        Map<String, Object> map = RestComponentHelper.initRestEndpointProperties("jetty", config);

        boolean cors = config.isEnableCORS();
        if (cors) {
             
            map.put("optionsEnabled", "true");
        }

        if (api) {
            map.put("matchOnUriPrefix", "true");
        }

        RestComponentHelper.addHttpRestrictParam(map, verb, cors);

        String url = RestComponentHelper.createRestConsumerUrl("jetty", scheme, host, port, path, map);

        JettyHttpEndpoint endpoint = (JettyHttpEndpoint) camelContext.getEndpoint(url, parameters);

        boolean binding = map.containsKey("httpBindingRef") || map.containsKey("httpBinding");

        if (!binding) {
             
            endpoint.setHttpBinding(new JettyRestHttpBinding(endpoint));
             
            endpoint.setEnableMultipartFilter(false);
        }

         
        Consumer consumer = endpoint.createConsumer(processor);
        if (config.getConsumerProperties() != null && !config.getConsumerProperties().isEmpty()) {
            setProperties(camelContext, consumer, config.getConsumerProperties());
        }

         
        ServiceHelper.startService(endpoint);

        return consumer;
    }

    private static ActiveMQMessage createActiveMQMessage(Exchange exchange) throws JMSException {
        Object body = exchange.getIn().getBody();
        if (body instanceof String) {
            ActiveMQTextMessage answer = new ActiveMQTextMessage();
            answer.setText((String) body);
            return answer;
        } else if (body instanceof Serializable) {
            ActiveMQObjectMessage answer = new ActiveMQObjectMessage();
            answer.setObject((Serializable) body);
            return answer;
        } else {
            return new ActiveMQMessage();
        }

    }

    private void initCsvRecordParameters() {
        if (separator == null) {
            for (Class<?> cl : models) {

                 
                CsvRecord csvRecord = cl.getAnnotation(CsvRecord.class);

                 
                Section section = cl.getAnnotation(Section.class);

                if (csvRecord != null) {
                    LOG.debug("Csv record: {}", csvRecord);

                     
                    skipFirstLine = csvRecord.skipFirstLine();
                    LOG.debug("Skip First Line parameter of the CSV: {}", skipFirstLine);

                     
                    skipField = csvRecord.skipField();
                    LOG.debug("Skip Field parameter of the CSV: {}", skipField);

                     
                    generateHeaderColumnNames = csvRecord.generateHeaderColumns();
                    LOG.debug("Generate header column names parameter of the CSV: {}", generateHeaderColumnNames);

                     
                    org.apache.camel.util.ObjectHelper.notNull(csvRecord.separator(),
                            "No separator has been defined in the @Record annotation");
                    separator = csvRecord.separator();
                    LOG.debug("Separator defined for the CSV: {}", separator);

                     
                    crlf = csvRecord.crlf();
                    LOG.debug("Carriage return defined for the CSV: {}", crlf);

                     
                    messageOrdered = csvRecord.isOrdered();
                    LOG.debug("Must CSV record be ordered: {}", messageOrdered);

                    if (org.apache.camel.util.ObjectHelper.isNotEmpty(csvRecord.quote())) {
                        quote = csvRecord.quote();
                        LOG.debug("Quoting columns with: {}", quote);
                    }

                    quoting = csvRecord.quoting();
                    LOG.debug("CSV will be quoted: {}", quoting);

                    autospanLine = csvRecord.autospanLine();
                    LOG.debug("Autospan line in last record: {}", autospanLine);

                     
                    allowEmptyStream = csvRecord.allowEmptyStream();
                    LOG.debug("Allow empty stream parameter of the CSV: {}", allowEmptyStream);

                     
                    quotingEscaped = csvRecord.quotingEscaped();
                    LOG.debug("Escape quote character flag of the CSV: {}", quotingEscaped);

                     
                    quotingOnlyWhenNeeded = csvRecord.quotingOnlyWhenNeeded();
                    LOG.debug("Quoting only when needed: {}", quotingOnlyWhenNeeded);

                     
                    endWithLineBreak = csvRecord.endWithLineBreak();
                    LOG.debug("End with line break: {}", endWithLineBreak);

                    removeQuotes = csvRecord.removeQuotes();
                    LOG.debug("Remove quotes: {}", removeQuotes);

                    trimLine = csvRecord.trimLine();
                    LOG.debug("Trim line: {}", trimLine);
                }

                if (section != null) {
                     
                    org.apache.camel.util.ObjectHelper.notNull(section.number(), "No number has been defined for the section");

                     
                    sections.put(cl.getName(), section.number());
                }
            }
        }
    }

    protected void ensureNamespacesCapacity(int size) {
        final int namespaceSize = namespacePrefix != null ? namespacePrefix.length : 0;
        if (size >= namespaceSize) {
            final int newSize = size > 7 ? 2 * size : 8;  
            if (TRACE_SIZING) {
                System.err.println("TRACE_SIZING namespaceSize " + namespaceSize + " ==> " + newSize);
            }
            final String[] newNamespacePrefix = new String[newSize];
            final String[] newNamespaceUri = new String[newSize];
            if (namespacePrefix != null) {
                System.arraycopy(namespacePrefix, 0, newNamespacePrefix, 0, namespaceEnd);
                System.arraycopy(namespaceUri, 0, newNamespaceUri, 0, namespaceEnd);
            }
            namespacePrefix = newNamespacePrefix;
            namespaceUri = newNamespaceUri;

            if (!allStringsInterned) {
                final int[] newNamespacePrefixHash = new int[newSize];
                if (namespacePrefixHash != null) {
                    System.arraycopy(namespacePrefixHash, 0, newNamespacePrefixHash, 0, namespaceEnd);
                }
                namespacePrefixHash = newNamespacePrefixHash;
            }
             
             
        }
    }

    public void unlisten(String requestUri) {
        if (listenerService != null) {
            lock.lock();
            try {
                listenerService.unregisterHandler(requestUri);
                consumerConfigurations.remove(requestUri);
            } finally {
                lock.unlock();
            }
        }
    }

    public static String stripSourceLocationLineNumber(String location) {
        int cnt = StringHelper.countChar(location, ':');
        if (cnt >= 1) {
            int pos = location.lastIndexOf(':');
            return location.substring(0, pos);
        } else {
            return location;
        }
    }

    static long write(FileChannel fileChannel, ByteBuffer byteBuffer, long position) throws IOException {
        long bytesWritten = 0;
        byteBuffer.flip();

        while (byteBuffer.hasRemaining()) {
            bytesWritten += fileChannel.write(byteBuffer, position + bytesWritten);
        }

        byteBuffer.flip();
        byteBuffer.clear();

        return bytesWritten;
    }

    private T getNextElement() {
        if (asn1InputStream == null) {
            return null;
        }

        try {
            ASN1Primitive current = getNextEntry();

            if (current != null) {
                return ObjectHelper.cast(clazz, createGenericTypeObject(current));
            } else {
                LOGGER.trace("close asn1InputStream");
                return null;
            }
        } catch (Exception exception) {
            throw new RuntimeCamelException(exception);
        }
    }

  public SSPTParser(java.io.InputStream stream, String encoding) {
	 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
	 token_source = new SSPTParserTokenManager(jj_input_stream);
	 token = new Token();
	 jj_ntk = -1;
	 jj_gen = 0;
	 for (int i = 0; i < 12; i++) jj_la1[i] = -1;
  }

    public Object sendBodyAndProperty(
            Endpoint endpoint, ExchangePattern pattern, final Object body,
            final String property, final Object propertyValue)
            throws CamelExecutionException {
        Exchange exchange = send(endpoint, pattern, createBodyAndPropertyProcessor(body, property, propertyValue));
        Object result = extractResultBody(exchange, pattern);
        if (pattern == ExchangePattern.InOnly) {
             
            return null;
        } else {
            return result;
        }
    }

    public static Expression fileOnlyNameNoExtensionExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                String name = fileOnlyNameExpression().evaluate(exchange, String.class);
                return FileUtil.stripExt(name);
            }

            @Override
            public String toString() {
                return "file:onlyname.noext";
            }
        };
    }

    public void marshal(Exchange exchange, Object o, OutputStream outputStream) throws Exception {
        IBaseResource iBaseResource;
        if (!(o instanceof IBaseResource)) {
            iBaseResource = exchange.getContext().getTypeConverter().mandatoryConvertTo(IBaseResource.class, exchange, o);
        } else {
            iBaseResource = (IBaseResource) o;
        }

        IParser parser = getFhirContext().newJsonParser();
        configureParser(parser);
        parser.encodeResourceToWriter(iBaseResource, new OutputStreamWriter(outputStream));

        if (isContentTypeHeader()) {
            exchange.getMessage().setHeader(Exchange.CONTENT_TYPE, parser.getEncoding().getResourceContentTypeNonLegacy());
        }
    }

    private void doHttpRequestWithQueryJobResponse(QueryJobResponseCallback callback, Request request) {
        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> responseHeaders, SalesforceException ex) {
                if (ex != null) {
                    callback.onResponse(null, responseHeaders, ex);
                    return;
                }
                QueryJob queryJob = null;
                try {
                    queryJob = DefaultBulkApiV2Client.this.unmarshalResponse(response, request,
                            QueryJob.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(queryJob, responseHeaders, ex);
            }
        });
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.aws.ddbstream.getRecords");

        if (message.getHeaders().containsKey(Ddb2StreamConstants.EVENT_SOURCE)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "aws.ddbstream." + message.getHeader(Ddb2StreamConstants.EVENT_SOURCE, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(Ddb2StreamConstants.EVENT_ID, String.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    public void process(Exchange exchange) throws Exception {

        Map<String, Object> headers = exchange.getIn().getHeaders();

         
        Object oid = null;

        if (headers.containsKey(HazelcastConstants.OBJECT_ID)) {
            oid = headers.get(HazelcastConstants.OBJECT_ID);
        }

        final HazelcastOperation operation = lookupOperation(exchange);

        switch (operation) {
            case PUT:
                this.put(oid, exchange);
                break;

            case GET:
                this.get(oid, exchange);
                break;

            case DELETE:
                this.delete(oid);
                break;

            case CLEAR:
                this.clear();
                break;

            case CONTAINS_KEY:
                this.containsKey(oid, exchange);
                break;

            case CONTAINS_VALUE:
                this.containsValue(exchange);
                break;

            default:
                throw new IllegalArgumentException(
                        String.format("The value '%s' is not allowed for parameter '%s' on the MULTIMAP cache.", operation,
                                HazelcastConstants.OPERATION));
        }

         
        HazelcastComponentHelper.copyHeaders(exchange);
    }

    private Object getKey(final Message message) throws Exception {
        String value;
        value = message.getHeader(CaffeineConstants.KEY, String.class);
        if (value == null) {
            value = configuration.getKey();
        }

        if (value == null) {
            throw new CamelExchangeException(
                    "No value provided in header or as default value (" + CaffeineConstants.KEY + ")", message.getExchange());
        }

        return value;
    }

    public static void findXmlRouters(Set<File> xmlFiles, boolean includeXml, boolean includeTest, MavenProject project) {
        if (includeXml) {
            for (Resource dir : project.getResources()) {
                findXmlFiles(new File(dir.getDirectory()), xmlFiles);
            }
            if (includeTest) {
                for (Resource dir : project.getTestResources()) {
                    findXmlFiles(new File(dir.getDirectory()), xmlFiles);
                }
            }
        }
    }

    private void createSetHeaderDefinitions(Object[] headerNamesAndExprs) {
        if (headerNamesAndExprs.length == 1 && headerNamesAndExprs[0] instanceof Map) {
            createHeadersFromMap((Map<?, ?>) headerNamesAndExprs[0]);
        } else if (headerNamesAndExprs.length % 2 != 0) {
            throw new IllegalArgumentException("Must be a Map or have an even number of arguments!");
        } else {
            for (int i = 0; i < headerNamesAndExprs.length; i += 2) {
                addHeader(headerNamesAndExprs[i], headerNamesAndExprs[i + 1]);
            }
        }
    }

    public RestDefinition enableCORS(boolean enableCORS) {
        if (getVerbs().isEmpty()) {
            this.enableCORS = Boolean.toString(enableCORS);
        } else {
             
            VerbDefinition verb = getVerbs().get(getVerbs().size() - 1);
            verb.setEnableCORS(Boolean.toString(enableCORS));
        }

        return this;
    }

    protected String getEndpointUri(Row r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    void onResult(String connectionKey) {
        lock.lock();
        try {
            connectionKeys.remove(connectionKey);
            if (connectionKeys.isEmpty()) {
                onComplete();
            }
        } finally {
            lock.unlock();
        }
    }

    private static TrustManagerFactory createTrustManagerFactory(
            CamelContext camelContext, SSLContextParameters sslContextParameters)
            throws Exception {
        final TrustManagersParameters trustManagers = sslContextParameters.getTrustManagers();
        if (trustManagers == null) {
            return null;
        }
        trustManagers.setCamelContext(camelContext);
        if (trustManagers.getKeyStore() != null) {
            trustManagers.getKeyStore().setCamelContext(camelContext);
        }

        TrustManagerFactory tmf = null;

        if (trustManagers.getKeyStore() != null) {
            String tmfAlgorithm = camelContext.resolvePropertyPlaceholders(trustManagers.getAlgorithm());
            if (tmfAlgorithm == null) {
                tmfAlgorithm = TrustManagerFactory.getDefaultAlgorithm();
            }

            if (trustManagers.getProvider() == null) {
                tmf = TrustManagerFactory.getInstance(tmfAlgorithm);
            } else {
                tmf = TrustManagerFactory.getInstance(tmfAlgorithm,
                        camelContext.resolvePropertyPlaceholders(trustManagers.getProvider()));
            }

            KeyStore ks = trustManagers.getKeyStore() == null ? null : trustManagers.getKeyStore().createKeyStore();
            tmf.init(ks);
        }
        return tmf;
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        Message in = exchange.getIn();
        Message out = exchange.getOut();
        MessageHelper.copyHeaders(exchange.getIn(), out, true);

        switch (cacheOperationFor(exchange)) {

            case GET:
                doGet(in, out);
                break;

            case PUT:
                doPut(in, out);
                break;

            case QUERY:
                doQuery(in, out, exchange);
                break;

            case REMOVE:
                doRemove(in, out);
                break;

            case CLEAR:
                doClear(in, out);
                break;

            case SIZE:
                doSize(in, out);
                break;

            case REBALANCE:
                doRebalance(in, out);
                break;

            case REPLACE:
                doReplace(in, out);
                break;

            default:
                break;
        }

        callback.done(false);
        return false;
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (propertiesFunction != null) {
            sb.append("GCP Secret Manager:");
            if (propertiesFunction.isUseDefaultInstance()) {
                sb.append("\n    Login: Default Instance");
            } else {
                sb.append("\n    Login: Service Account Key File");
            }
            GcpVaultConfiguration gcp = getCamelContext().getVaultConfiguration().getGcpVaultConfiguration();
            if (gcp != null) {
                sb.append(String.format("\n    Refresh Enabled: %s", gcp.isRefreshEnabled()));
                sb.append(String.format("\n    Refresh Period: %s", gcp.getRefreshPeriod()));
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                String s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Check: %s", s));
                last = secretsRefreshTask.getLastReloadTime();
                s = last != null ? TimeUtils.printSince(last.toEpochMilli()) : "none";
                sb.append(String.format("\n    Last Reload: %s", s));
            }
            sb.append("\n\nSecrets in use:");

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                String age = last != null ? TimeUtils.printSince(last.toEpochMilli()) : null;
                if (age != null) {
                    sb.append(String.format("\n    %s (age: %s)", sec, age));
                } else {
                    sb.append(String.format("\n    %s", sec));
                }
            }
        }

        return sb.toString();
    }

    protected void doPushTag(Exchange exchange, String operation) throws GitAPIException {
        Iterable<PushResult> result = null;
        try {
            if (ObjectHelper.isEmpty(endpoint.getRemoteName())) {
                throw new IllegalArgumentException("Remote name must be specified to execute " + operation);
            }
            if (ObjectHelper.isEmpty(endpoint.getTagName())) {
                throw new IllegalArgumentException("Tag Name must be specified to execute " + operation);
            }
            if (ObjectHelper.isNotEmpty(endpoint.getUsername()) && ObjectHelper.isNotEmpty(endpoint.getPassword())) {
                UsernamePasswordCredentialsProvider credentials
                        = new UsernamePasswordCredentialsProvider(endpoint.getUsername(), endpoint.getPassword());
                result = git.push().setCredentialsProvider(credentials).setRemote(endpoint.getRemoteName())
                        .add(Constants.R_TAGS + endpoint.getTagName()).call();
            } else {
                result = git.push().setRemote(endpoint.getRemoteName()).add(Constants.R_TAGS + endpoint.getTagName()).call();
            }
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
        updateExchange(exchange, result);
    }

    private void processUpsertSobject(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String sObjectName = determineSObjectName(exchange);
        String sObjectExtIdValue;
        final String sObjectExtIdName = getParameter(SOBJECT_EXT_ID_NAME, exchange, IGNORE_BODY, NOT_OPTIONAL);

         
        Object oldValue = null;
        final AbstractSObjectBase sObjectBase = exchange.getIn().getBody(AbstractSObjectBase.class);
        if (sObjectBase != null) {
            oldValue = getAndClearPropertyValue(sObjectBase, sObjectExtIdName);
            sObjectExtIdValue = oldValue.toString();
             
            sObjectBase.clearBaseFields();
        } else {
            sObjectExtIdValue = getParameter(SOBJECT_EXT_ID_VALUE, exchange, IGNORE_BODY, NOT_OPTIONAL);
        }

        final Object finalOldValue = oldValue;
        restClient.upsertSObject(sObjectName, sObjectExtIdName, sObjectExtIdValue, determineHeaders(exchange),
                getRequestStream(exchange), new RestClient.ResponseCallback() {
                    @Override
                    public void onResponse(InputStream response, Map<String, String> headers, SalesforceException exception) {
                        restoreFields(exchange, sObjectBase, null, sObjectExtIdName, finalOldValue);
                        processResponse(exchange, response, headers, exception, callback);
                    }
                });
    }

    private void update(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName = getCollectionName(in);
        Collection collection = this.client.getCollection(collectionName, embeddingFunction);

        List<String> ids = in.getHeader(ChromaHeaders.IDS, List.class);
        List<Embedding> embeddings = getEmbeddings(in);
        List<Map<String, String>> metadatas = in.getHeader(ChromaHeaders.METADATAS, List.class);
        List<String> documents = in.getBody(List.class);

        collection.updateEmbeddings(embeddings, metadatas, documents, ids);
        in.setHeader(ChromaHeaders.OPERATION_STATUS, "SUCCESS");
    }

    private Collection<Consumer<byte[]>> createMultipleConsumers(final PulsarEndpoint pulsarEndpoint) {
        final Collection<Consumer<byte[]>> consumers = new LinkedList<>();
        final PulsarConfiguration configuration = pulsarEndpoint.getPulsarConfiguration();

        for (int i = 0; i < configuration.getNumberOfConsumers(); i++) {
            final String consumerName = configuration.getConsumerNamePrefix() + i;
            try {
                ConsumerBuilder<byte[]> builder
                        = CommonCreationStrategyImpl.getBuilder(consumerName, pulsarEndpoint, pulsarConsumer);

                consumers.add(builder.subscriptionType(SubscriptionType.Shared).subscribe());
            } catch (PulsarClientException exception) {
                LOGGER.error("A PulsarClientException occurred when creating Consumer {}, {}", consumerName,
                        exception.getMessage(), exception);
            }
        }
        return consumers;
    }

    public static String getType(String type, boolean enumType, boolean isDuration) {
        if (enumType) {
            return "enum";
        } else if (isDuration) {
            return "duration";
        } else if (type == null) {
             
            return "object";
        } else if (type.equals(URI.class.getName()) || type.equals(URL.class.getName())) {
            return "string";
        } else if (type.equals(File.class.getName())) {
            return "string";
        } else if (type.equals(Date.class.getName())) {
            return "string";
        } else if (type.startsWith("java.lang.Class")) {
            return "string";
        } else if (type.startsWith("java.util.List") || type.startsWith("java.util.Collection")) {
            return "array";
        } else if (type.equals(Duration.class.getName())) {
            return "duration";
        }

        String primitive = getPrimitiveType(type);
        if (primitive != null) {
            return primitive;
        }

        return "object";
    }

    protected static AnnotationSpec yamlPropertyWithFormat(
            String name, String type, String format, boolean required, boolean deprecated) {
        AnnotationSpec.Builder builder = AnnotationSpec.builder(CN_YAML_PROPERTY);
        builder.addMember("name", "$S", name);
        builder.addMember("type", "$S", type);
        builder.addMember("format", "$S", format);

        if (required) {
            builder.addMember("required", "$L", required);
        }
        if (deprecated) {
            builder.addMember("deprecated", "$L", deprecated);
        }

        return builder.build();
    }

    protected void processStrategyCommit(
            GenericFileProcessStrategy<T> processStrategy, Exchange exchange, GenericFile<T> file) {
        if (Boolean.TRUE.equals(endpoint.isIdempotent())) {
             
             
            String key = absoluteFileName;
            if (endpoint.getIdempotentKey() != null) {
                Exchange dummy = GenericFileHelper.createDummy(endpoint, exchange, () -> file);
                key = endpoint.getIdempotentKey().evaluate(dummy, String.class);
            }
             
            if (key != null) {
                 
                if (endpoint.isIdempotentEager()) {
                    endpoint.getIdempotentRepository().confirm(key);
                } else {
                    endpoint.getIdempotentRepository().add(key);
                }
            }
        }

        handleDoneFile(exchange);

        try {
            LOG.trace("Commit file strategy: {} for file: {}", processStrategy, file);
            processStrategy.commit(operations, endpoint, exchange, file);
        } catch (Exception e) {
            handleException("Error during commit", exchange, e);
        }
    }

    public FluentProducerTemplate withExchangeProperty(String key, Object value) {
        DefaultFluentProducerTemplate clone = checkCloned();

        if (clone.processorSupplier != null) {
            throw new IllegalArgumentException(
                    "Cannot use both withExchangeProperty and withProcessor with FluentProducerTemplate");
        }

        Map<String, Object> map = clone.exchangeProperties;
        if (map == null) {
            map = new LinkedHashMap<>();
            clone.exchangeProperties = map;
        }
        map.put(key, value);
        return clone;
    }

    private void copyAgentLibDependencies(MavenGav gav) {
        try {
            List<MavenArtifact> artifacts = getDownloader().resolveArtifacts(
                    List.of(gav.toString()), Set.of(), true, gav.getVersion().contains("SNAPSHOT"));
            for (MavenArtifact artifact : artifacts) {
                Path target = Paths.get(BUILD_DIR, "agent", artifact.getFile().getName());
                if (Files.exists(target) || EXCLUDED_GROUP_IDS.contains(artifact.getGav().getGroupId())) {
                    continue;
                }
                Files.copy(artifact.getFile().toPath(), target);
            }
        } catch (MavenResolutionException e) {
            printer().printErr("Error resolving the artifact: " + gav + " due to: " + e.getMessage());
        } catch (IOException e) {
            printer().printErr("Error copying the artifact: " + gav + " due to: " + e.getMessage());
        }
    }

    public static Expression nullExpression() {
        return new ExpressionAdapter() {
            @Override
            public Object evaluate(Exchange exchange) {
                return null;
            }

            @Override
            public String toString() {
                return "null";
            }
        };
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.pdfbox.pdmodel.PDDocument.class, byte[].class, false,
            (type, exchange, value) -> {
                Object answer = getPdfConverter().convertToPDF((byte[]) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.pdfbox.pdmodel.PDDocument.class, java.io.File.class, false,
            (type, exchange, value) -> {
                Object answer = getPdfConverter().convertToPDF((java.io.File) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.pdfbox.pdmodel.PDDocument.class, java.io.InputStream.class, false,
            (type, exchange, value) -> {
                Object answer = getPdfConverter().toPDDocument((java.io.InputStream) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public void createSObjectMultipart(
            String sObjectName, Object sObjectDto, InputStream sObject,
            Map<String, List<String>> headers, ResponseCallback callback) {
        try {
            final Request post = getRequest(HttpMethod.POST, sobjectsUrl(sObjectName), headers);

            setAccessToken(post);

            try (MultiPartRequestContent multipartContent = new MultiPartRequestContent()) {
                ObjectMapper objectMapper = new ObjectMapper();
                JsonNode jsonNode = objectMapper.readTree(sObject);

                if (jsonNode.isObject()) {
                    ObjectNode objectNode = (ObjectNode) jsonNode;
                    ObjectNode cleanJson = objectNode.deepCopy();

                    Map<String, InputStream> binaryFields = getBinaryFieldMap(sObjectDto);

                    if (!binaryFields.isEmpty()) {

                         
                        for (String fieldName : binaryFields.keySet()) {
                            cleanJson.remove(fieldName);
                        }

                         
                        String cleanJsonString = objectMapper.writeValueAsString(cleanJson);
                        multipartContent.addPart(new MultiPart.ContentSourcePart(
                                "entity", null,
                                HttpFields.build().add(HttpHeader.CONTENT_TYPE, APPLICATION_JSON_UTF8),
                                new InputStreamRequestContent(
                                        new ByteArrayInputStream(cleanJsonString.getBytes(StandardCharsets.UTF_8)))));

                         
                        for (Map.Entry<String, InputStream> entry : binaryFields.entrySet()) {
                            String fieldName = entry.getKey();
                            InputStream binaryData = entry.getValue();

                            multipartContent.addPart(new MultiPart.ContentSourcePart(
                                    fieldName, "temp-file-name.doc",
                                    HttpFields.build().add(HttpHeader.CONTENT_TYPE, "application/octet-stream"),
                                    new InputStreamRequestContent(binaryData)));
                        }
                    } else {
                         
                        callback.onResponse(null, Collections.emptyMap(),
                                new SalesforceException("createSObjectMultipart called but no binary fields found", null));
                        return;
                    }
                } else {
                     
                    multipartContent.addPart(new MultiPart.ContentSourcePart(
                            "entity", null,
                            HttpFields.build().add(HttpHeader.CONTENT_TYPE, APPLICATION_JSON_UTF8),
                            new InputStreamRequestContent(sObject)));
                }

                post.body(multipartContent);
            }

            doHttpRequest(post, new DelegatingClientCallback(callback));
        } catch (Exception e) {
             
            callback.onResponse(null, Collections.emptyMap(),
                    new SalesforceException("Failed to process multipart request: " + e.getMessage(), e));
        }
    }

    public static Object deserializeJavaObjectFromStream(InputStream is) throws ClassNotFoundException, IOException {
        if (is == null) {
            return null;
        }

        Object answer;
        ObjectInputStream ois = new ObjectInputStream(is);
        try {
            answer = ois.readObject();
        } finally {
            IOHelper.close(ois);
        }

        return answer;
    }

    public String apply(String remainder) {
        String key = remainder;
        String subkey = null;
        String returnValue = null;
        String defaultValue = null;
        String version = null;
        if (remainder.contains("#")) {
            key = StringHelper.before(remainder, "#");
            subkey = StringHelper.after(remainder, "#");
            defaultValue = StringHelper.after(subkey, ":");
            if (ObjectHelper.isNotEmpty(defaultValue)) {
                if (defaultValue.contains("@")) {
                    version = StringHelper.after(defaultValue, "@");
                    defaultValue = StringHelper.before(defaultValue, "@");
                }
            }
            if (subkey.contains(":")) {
                subkey = StringHelper.before(subkey, ":");
            }
            if (subkey.contains("@")) {
                version = StringHelper.after(subkey, "@");
                subkey = StringHelper.before(subkey, "@");
            }
        } else if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
            if (remainder.contains("@")) {
                version = StringHelper.after(remainder, "@");
                defaultValue = StringHelper.before(defaultValue, "@");
            }
        } else {
            if (remainder.contains("@")) {
                key = StringHelper.before(remainder, "@");
                version = StringHelper.after(remainder, "@");
            }
        }

        if (key != null) {
            try {
                returnValue = getSecretFromSource(key, subkey, defaultValue, version);
            } catch (JsonProcessingException e) {
                throw new RuntimeCamelException(
                        "Error getting secret from vault using key: " + key + " due to: " + e.getMessage(), e);
            }
        }

        return returnValue;
    }

        protected void deliverToOnRedeliveryProcessor() {
            if (onRedeliveryProcessor == null) {
                return;
            }

            if (LOG.isTraceEnabled()) {
                LOG.trace("Redelivery processor {} is processing Exchange: {} before its redelivered",
                        onRedeliveryProcessor, exchange);
            }

             
            try {
                onRedeliveryProcessor.process(exchange);
            } catch (Exception e) {
                exchange.setException(e);
            }
            LOG.trace("Redelivery processor done");
        }

    private long determineWaitTimeout(final Exchange exchange, Athena2Configuration configuration) {
        Long waitTimeout = exchange.getIn().getHeader(Athena2Constants.WAIT_TIMEOUT, Long.class);

        if (ObjectHelper.isEmpty(waitTimeout)) {
            waitTimeout = configuration.getWaitTimeout();
            LOG.trace("AWS Athena wait timeout is missing, using default one [{}]", waitTimeout);
        }

        if (ObjectHelper.isEmpty(waitTimeout)) {
            throw new IllegalArgumentException("AWS Athena wait timeout required.");
        }

        if (waitTimeout < 0) {
            throw new IllegalArgumentException("AWS Athena wait timeout must be >= 0");
        }

        return waitTimeout;
    }

    public void setData(T data) {
        Objects.requireNonNull(data, "data must be not null");
        if (this.data != null) {
            throw new IllegalStateException("data has already been set");
        } else if (this.exception != null) {
            throw new IllegalStateException("an exception has already been set");
        }

        this.data = data;
        flushCycle();
    }

    protected void doStart() throws Exception {
         
         
        boolean startScheduler = isStartScheduler();
        setStartScheduler(false);
        try {
            super.doStart();
            if (endpoint.isAutoCreate() && hasStartingDirectory()) {
                String dir = endpoint.getConfiguration().getDirectory();
                LOG.debug("Auto creating directory: {}", dir);
                try {
                    connectIfNecessary();
                    operations.buildDirectory(dir, true);
                } catch (GenericFileOperationFailedException e) {
                     
                    LOG.warn(
                            "Error auto creating directory: " + dir + " due " + e.getMessage() + ". This exception is ignored.",
                            e);
                }
            }
        } finally {
            if (startScheduler) {
                setStartScheduler(true);
                startScheduler();
            }
        }
    }

    protected void doStart() throws Exception {
        super.doStart();

        String accessKey = System.getenv(CAMEL_AWS_VAULT_ACCESS_KEY_ENV);
        String secretKey = System.getenv(CAMEL_AWS_VAULT_SECRET_KEY_ENV);
        String region = System.getenv(CAMEL_AWS_VAULT_REGION_ENV);
        boolean useDefaultCredentialsProvider
                = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_USE_DEFAULT_CREDENTIALS_PROVIDER_ENV));
        boolean useProfileCredentialsProvider
                = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_USE_PROFILE_CREDENTIALS_PROVIDER_ENV));
        String profileName = System.getenv(CAMEL_AWS_VAULT_PROFILE_NAME_ENV);
        boolean isOverrideEndpoint = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_IS_OVERRIDE_ENDPOINT));
        String uriEndpointOverride = System.getenv(CAMEL_AWS_VAULT_URI_ENDPOINT_OVERRIDE);
        if (ObjectHelper.isEmpty(accessKey) && ObjectHelper.isEmpty(secretKey) && ObjectHelper.isEmpty(region)) {
            AwsVaultConfiguration awsVaultConfiguration = getCamelContext().getVaultConfiguration().aws();
            if (ObjectHelper.isNotEmpty(awsVaultConfiguration)) {
                accessKey = awsVaultConfiguration.getAccessKey();
                secretKey = awsVaultConfiguration.getSecretKey();
                region = awsVaultConfiguration.getRegion();
                useDefaultCredentialsProvider = awsVaultConfiguration.isDefaultCredentialsProvider();
                useProfileCredentialsProvider = awsVaultConfiguration.isProfileCredentialsProvider();
                profileName = awsVaultConfiguration.getProfileName();
                isOverrideEndpoint = awsVaultConfiguration.isOverrideEndpoint();
                uriEndpointOverride = awsVaultConfiguration.getUriEndpointOverride();
            }
        }
        this.region = region;
        if (ObjectHelper.isNotEmpty(accessKey) && ObjectHelper.isNotEmpty(secretKey) && ObjectHelper.isNotEmpty(region)) {
            SsmClientBuilder clientBuilder = SsmClient.builder();
            AwsBasicCredentials cred = AwsBasicCredentials.create(accessKey, secretKey);
            clientBuilder = clientBuilder.credentialsProvider(StaticCredentialsProvider.create(cred));
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else if (useDefaultCredentialsProvider && ObjectHelper.isNotEmpty(region)) {
            this.defaultCredentialsProvider = true;
            SsmClientBuilder clientBuilder = SsmClient.builder();
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else if (useProfileCredentialsProvider && ObjectHelper.isNotEmpty(profileName)) {
            this.profleCredentialsProvider = true;
            this.profileName = profileName;
            SsmClientBuilder clientBuilder = SsmClient.builder();
            clientBuilder.credentialsProvider(ProfileCredentialsProvider.create(profileName));
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else {
            throw new RuntimeCamelException(
                    "Using the AWS Parameter Store Properties Function requires setting AWS credentials as application properties or environment variables");
        }
    }

    public Expression createExpression(CamelContext camelContext, String expression) {
        ObjectHelper.notNull(left, "left node", this);
        ObjectHelper.notNull(right, "right node", this);

        final Expression leftExp = left.createExpression(camelContext, expression);
        final Expression rightExp = right.createExpression(camelContext, expression);

        if (operator == LogicalOperatorType.AND) {
            return createAndExpression(leftExp, rightExp);
        } else if (operator == LogicalOperatorType.OR) {
            return createOrExpression(leftExp, rightExp);
        }

        throw new SimpleParserException("Unknown logical operator " + operator, token.getIndex());
    }

    protected void doStart() throws Exception {
        contextServicePlugins = ServiceLoader.load(ContextServicePlugin.class,
                camelContext.getApplicationContextClassLoader());
        for (ContextServicePlugin plugin : contextServicePlugins) {
            try {
                plugin.load(camelContext);
            } catch (Exception e) {
                LOG.warn(
                        "Loading of plugin {} failed, however the exception will be ignored so others plugins can be initialized. Reason: {}",
                        plugin.getClass().getName(), e.getMessage(), e);
            }
        }
    }

    private boolean sleep() {
        LOG.trace("Exclusive read lock not granted. Sleeping for {} millis.", checkInterval);
        try {
            Thread.sleep(checkInterval);
            return false;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.debug("Sleep interrupted while waiting for exclusive read lock, so breaking out");
            return true;
        }
    }

    protected void prepareDataFormatConfig(Map<String, Object> properties) {
        properties.put("keyUserid", definition.getKeyUserid());
        properties.put("signatureKeyUserid", definition.getSignatureKeyUserid());
        properties.put("password", definition.getPassword());
        properties.put("signaturePassword", definition.getSignaturePassword());
        properties.put("keyFileName", definition.getKeyFileName());
        properties.put("signatureKeyFileName", definition.getSignatureKeyFileName());
        properties.put("signatureKeyRing", definition.getSignatureKeyRing());
        properties.put("armored", definition.getArmored());
        properties.put("integrity", definition.getIntegrity());
        properties.put("provider", definition.getProvider());
        properties.put("algorithm", definition.getAlgorithm());
        properties.put("compressionAlgorithm", definition.getCompressionAlgorithm());
        properties.put("hashAlgorithm", definition.getHashAlgorithm());
        properties.put("signatureVerificationOption", definition.getSignatureVerificationOption());
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        StringTemplateEndpoint answer = new StringTemplateEndpoint(uri, this, remaining);
        answer.setContentCache(contentCache);
        answer.setAllowTemplateFromHeader(allowTemplateFromHeader);
        answer.setAllowContextMapAll(allowContextMapAll);
        setProperties(answer, parameters);

         
        if (ResourceHelper.isHttpUri(remaining)) {
            remaining = ResourceHelper.appendParameters(remaining, parameters);
            answer.setResourceUri(remaining);
        }

        return answer;
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jph = (JsonObject) root.get("platform-http");
                        if (jph != null) {
                            String server = jph.getString("server");
                            JsonArray arr = (JsonArray) jph.get("endpoints");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    JsonObject jo = (JsonObject) arr.get(i);
                                    row.server = server;
                                    row.url = jo.getString("url");
                                    row.path = jo.getString("path");
                                    row.verbs = jo.getString("verbs");
                                    row.consumes = jo.getString("consumes");
                                    row.produces = jo.getString("produces");
                                    rows.add(row);
                                }
                            }
                            if (all) {
                                arr = (JsonArray) jph.get("managementEndpoints");
                                if (arr != null) {
                                    for (int i = 0; i < arr.size(); i++) {
                                        row = row.copy();
                                        JsonObject jo = (JsonObject) arr.get(i);
                                        row.server = server;
                                        row.url = jo.getString("url");
                                        row.path = jo.getString("path");
                                        row.verbs = jo.getString("verbs");
                                        row.consumes = jo.getString("consumes");
                                        row.produces = jo.getString("produces");
                                        rows.add(row);
                                    }
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("URL").dataAlign(HorizontalAlign.LEFT).with(r -> r.url),
                    new Column().header("METHOD").dataAlign(HorizontalAlign.LEFT).with(r -> r.verbs),
                    new Column().header("CONTENT-TYPE").dataAlign(HorizontalAlign.LEFT).with(this::getContent))));
        }

        return 0;
    }

    public KeyPair rotateKey(String oldKeyId, String newKeyId, String algorithm) throws Exception {
        LOG.info("Rotating key from {} to {}", oldKeyId, newKeyId);

         
        KeyMetadata oldMetadata = getKeyMetadata(oldKeyId);
        if (oldMetadata == null) {
            throw new IllegalArgumentException("Old key not found: " + oldKeyId);
        }

         
        oldMetadata.setStatus(KeyMetadata.KeyStatus.DEPRECATED);
        updateKeyMetadata(oldKeyId, oldMetadata);

         
        KeyPair newKeyPair = generateKeyPair(algorithm, newKeyId);

        LOG.info("Key rotation completed: {} -> {}", oldKeyId, newKeyId);
        return newKeyPair;
    }

    private void deleteVolume(Exchange exchange) throws RequestUnsuccessfulException, DigitalOceanException {
        String volumeId = exchange.getIn().getHeader(DigitalOceanHeaders.ID, String.class);
        Delete delete;
        if (ObjectHelper.isEmpty(volumeId)) {
            String name = exchange.getIn().getHeader(DigitalOceanHeaders.NAME, String.class);
            String region = exchange.getIn().getHeader(DigitalOceanHeaders.REGION, String.class);

            if (ObjectHelper.isEmpty(name) && ObjectHelper.isEmpty(region)) {
                throw new IllegalArgumentException(
                        DigitalOceanHeaders.ID + " or " + DigitalOceanHeaders.NAME + " and " + DigitalOceanHeaders.REGION
                                                   + " must be specified");
            }

            delete = getEndpoint().getDigitalOceanClient().deleteVolume(name, region);

        } else {
            delete = getEndpoint().getDigitalOceanClient().deleteVolume(volumeId);
        }

        LOG.trace("Delete Volume [{}] ", delete);
        exchange.getMessage().setBody(delete);

    }

    public void onExchangeDone(Exchange exchange) {
         
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(registerTemplates, registerKamelets);
            if (level <= 1) {
                super.onExchangeDone(exchange);
            }
        } else {
            super.onExchangeDone(exchange);
        }
    }

    protected ScheduledExecutorService getExecutorService(
            ScheduledExecutorService executorService, String executorServiceRef) {

        lock.lock();
        try {
            executorServiceRef = parseString(executorServiceRef);
            if (executorService == null || executorService.isShutdown()) {
                 
                 
                if (executorServiceRef != null) {
                    executorService = lookupByNameAndType(executorServiceRef, ScheduledExecutorService.class);
                    if (executorService == null) {
                        ExecutorServiceManager manager = camelContext.getExecutorServiceManager();
                        ThreadPoolProfile profile = manager.getThreadPoolProfile(executorServiceRef);
                        executorService = manager.newScheduledThreadPool(this, executorServiceRef, profile);
                    }
                    if (executorService == null) {
                        throw new IllegalArgumentException("ExecutorService " + executorServiceRef + " not found in registry.");
                    }
                } else {
                     
                     
                     
                    executorService = null;
                }
            }
            return executorService;
        } finally {
            lock.unlock();
        }
    }

    public static Expression collateExpression(final String expression, final int group) {
        return new ExpressionAdapter() {
            private Expression exp;

            @Override
            public void init(CamelContext context) {
                 
                exp = context.resolveLanguage("simple").createExpression(expression);
                exp.init(context);
                exp = ExpressionBuilder.groupIteratorExpression(exp, null, Integer.toString(group), false);
                exp.init(context);
            }

            @Override
            public Object evaluate(Exchange exchange) {
                return exp.evaluate(exchange, Object.class);
            }

            @Override
            public String toString() {
                return "collate(" + expression + "," + group + ")";
            }
        };
    }

    private static GenericFileExclusiveReadLockStrategy<FTPFile> getExclusiveReadLockStrategy(Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<FTPFile> strategy
                = (GenericFileExclusiveReadLockStrategy<FTPFile>) params.get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<FTPFile> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                FtpChangedExclusiveReadLockStrategy readLockStrategy = new FtpChangedExclusiveReadLockStrategy();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            }
        }

        return null;
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    public static void initializeSantuario() {
         
        boolean wasSet = false;
        try {
             
            String lineBreakPropName = "org.apache.xml.security.ignoreLineBreaks";
            if (System.getProperty(lineBreakPropName) == null) {
                System.setProperty(lineBreakPropName, "true");
                wasSet = false;
            } else {
                wasSet = true;
            }
        } catch (Exception t) {
             
        }

        org.apache.xml.security.Init.init();

        if (!wasSet) {
            try {
                Field f = XMLUtils.class.getDeclaredField("ignoreLineBreaks");
                f.setAccessible(true);
                f.set(null, Boolean.TRUE);
            } catch (Exception t) {
                 
            }
        }
    }

    private CopyArchiveFromContainerCmd executeCopyFileContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Copy File/Folder Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);
        String resource = DockerHelper.getProperty(DockerConstants.DOCKER_RESOURCE, configuration, message, String.class);

        if (containerId == null || resource == null) {
            throw new IllegalArgumentException("Container ID and Resource must be specified");
        }

        CopyArchiveFromContainerCmd copyArchiveFromContainerCmd = client.copyArchiveFromContainerCmd(containerId, resource);

        String hostPath = DockerHelper.getProperty(DockerConstants.DOCKER_HOST_PATH, configuration, message, String.class);

        if (hostPath != null) {
            copyArchiveFromContainerCmd.withHostPath(hostPath);
        }

        return copyArchiveFromContainerCmd;

    }

    public String apply(String remainder) {
        String key = remainder;
        String defaultValue = null;

        if (remainder.contains(":")) {
            key = StringHelper.before(remainder, ":");
            defaultValue = StringHelper.after(remainder, ":");
        }

         
        if (key != null) {
             
            String port = IOHelper.lookupEnvironmentVariable(key + PORT_PREFIX);
            if (port != null) {
                return port;
            } else {
                return defaultValue;
            }
        }

        return defaultValue;
    }

    public void onStart(Route route) {
         
         
         
        statisticsMap.computeIfAbsent(route,
                it -> {
                    boolean skip = !configuration.isRouteEnabled();
                     
                    if (!skip) {
                        skip = (it.isCreatedByKamelet() && !registerKamelets)
                                || (it.isCreatedByRouteTemplate() && !registerTemplates);
                    }
                    if (!skip && configuration.getExcludePattern() != null) {
                        String[] patterns = configuration.getExcludePattern().split(",");
                        skip = PatternHelper.matchPatterns(route.getRouteId(), patterns);
                    }
                    LOG.debug("Capturing metrics for route: {} -> {}", route.getRouteId(), skip);
                    if (skip) {
                        return null;
                    }
                    return new MetricsStatistics(
                            getMeterRegistry(), it.getCamelContext(), it, getNamingStrategy(), configuration);
                });
    }

        public Builder instance(Object instance) {
             
            if (instance instanceof Class) {
                this.beanType = (Class<?>) instance;
                this.instance = null;
            } else {
                this.beanType = null;
                this.instance = instance;
            }
            return this;
        }

    protected static List<String> getParameters(String path) {
        List<String> parameters = null;

        int startIndex = path.indexOf('{');
        while (startIndex != -1) {
            int endIndex = path.indexOf('}', startIndex);
            if (endIndex != -1) {
                if (parameters == null) {
                    parameters = new ArrayList<>();
                }
                parameters.add(path.substring(startIndex + 1, endIndex));
                startIndex = path.indexOf('{', endIndex);
            } else {
                 
                startIndex = -1;
            }
        }

        return parameters == null ? Collections.emptyList() : parameters;
    }

    protected boolean implementType(ClassInfo ci, DotName interfaceType) {
        if (ci == null) {
            return false;
        }
        if (ci.name().equals(interfaceType)) {
            return true;
        }

        for (DotName name : ci.interfaceNames()) {
            if (name.equals(interfaceType)) {
                return true;
            }
        }

        DotName superName = ci.superName();
        if (superName != null) {
            return implementType(
                    view.getClassByName(superName),
                    interfaceType);
        }

        return false;
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jo = (JsonObject) root.get("internal-tasks");
                        if (jo != null) {
                            JsonArray arr = (JsonArray) jo.get("tasks");
                            for (int i = 0; i < arr.size(); i++) {
                                jo = (JsonObject) arr.get(i);
                                row = row.copy();
                                row.task = jo.getString("name");
                                row.status = jo.getString("status");
                                row.attempts = jo.getLong("attempts");
                                row.delay = jo.getLong("delay");
                                row.elapsed = jo.getLong("elapsed");
                                row.firstTime = jo.getLong("firstTime");
                                row.lastTime = jo.getLong("lastTime");
                                row.nextTime = jo.getLong("nextTime");
                                row.error = jo.getString("error");
                                rows.add(row);
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("TASK").dataAlign(HorizontalAlign.LEFT).with(r -> r.task),
                    new Column().header("STATUS").dataAlign(HorizontalAlign.LEFT).with(r -> r.status),
                    new Column().header("ATTEMPT").dataAlign(HorizontalAlign.LEFT).with(r -> "" + r.attempts),
                    new Column().header("DELAY").dataAlign(HorizontalAlign.LEFT).with(r -> "" + r.delay),
                    new Column().header("ELAPSED").dataAlign(HorizontalAlign.LEFT).with(this::getElapsed),
                    new Column().header("FIRST").dataAlign(HorizontalAlign.LEFT).with(this::getFirst),
                    new Column().header("LAST").dataAlign(HorizontalAlign.LEFT).with(this::getLast),
                    new Column().header("NEXT").dataAlign(HorizontalAlign.LEFT).with(this::getNext),
                    new Column().header("FAILURE").dataAlign(HorizontalAlign.LEFT)
                            .maxWidth(140, OverflowBehaviour.NEWLINE)
                            .with(r -> r.error))));
        }

        return 0;
    }

    private static void setAdditionalConfiguration(
            CamelContext camelContext, RestConfiguration config, DataFormat dataFormat, String prefix) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            PropertyBindingSupport.build().bind(camelContext, dataFormat, copy);
        }
    }

    private void createRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).roles().create((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Role created successfully");
            }
        } else {
            RoleRepresentation role = new RoleRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME))) {
                String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
                role.setName(roleName);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION))) {
                    role.setDescription(exchange.getIn().getHeader(KeycloakConstants.ROLE_DESCRIPTION, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_ROLE_NAME);
            }
            keycloakClient.realm(realmName).roles().create(role);
            Message message = getMessageForResponse(exchange);
            message.setBody("Role created successfully");
        }
    }

    public void onExchangeDone(Exchange exchange) {
         
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(registerTemplates, registerKamelets);
            if (level <= 1) {
                super.onExchangeDone(exchange);
            }
        } else {
            super.onExchangeDone(exchange);
        }
    }

    protected ScheduledExecutorService getExecutorService(
            ScheduledExecutorService executorService, String executorServiceRef) {
        lock.lock();
        try {
            if (executorService == null || executorService.isShutdown()) {
                 
                 
                if (executorServiceRef != null) {
                    executorService = lookupByNameAndType(executorServiceRef, ScheduledExecutorService.class);
                    if (executorService == null) {
                        ExecutorServiceManager manager = camelContext.getExecutorServiceManager();
                        ThreadPoolProfile profile = manager.getThreadPoolProfile(executorServiceRef);
                        executorService = manager.newScheduledThreadPool(this, executorServiceRef, profile);
                    }
                    if (executorService == null) {
                        throw new IllegalArgumentException("ExecutorService " + executorServiceRef + " not found in registry.");
                    }
                } else {
                     
                     
                     
                    executorService = null;
                }
            }
            return executorService;
        } finally {
            lock.unlock();
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.google.mail.stream.consume");

        if (message.getHeaders().containsKey(GoogleMailStreamConstants.MAIL_FROM)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "google.mail.stream." + message.getHeader(GoogleMailStreamConstants.MAIL_FROM, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT,
                message.getHeader(GoogleMailStreamConstants.MAIL_SUBJECT, String.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    private boolean updateImportantHeaderKeys(File camelDir, Set<String> importants) throws Exception {
         
        File java = new File(camelDir, "src/main/java/org/apache/camel/util/ImportantHeaderUtils.java");
        String text = PackageHelper.loadText(java);
        String spaces20 = "                    ";
        String spaces12 = "            ";

        StringJoiner sb = new StringJoiner(",\n");
        for (String name : importants) {
            sb.add(spaces20 + "\"" + name + "\"");
        }
        String changed = sb.toString();

        String existing = Strings.between(text, KEYS_START_TOKEN, KEYS_END_TOKEN);
        if (existing != null) {
             
            existing = existing.trim();
            changed = changed.trim();
            if (existing.equals(changed)) {
                return false;
            } else {
                String before = Strings.before(text, KEYS_START_TOKEN);
                String after = Strings.after(text, KEYS_END_TOKEN);
                text = before + KEYS_START_TOKEN + "\n" + spaces20 + changed + "\n" + spaces12 + KEYS_END_TOKEN + after;
                PackageHelper.writeText(java, text);
                return true;
            }
        }

        return false;
    }

    public PathHandler addPrefixPath(final String path, final HttpHandler handler) {
        lock.lock();
        try {
            super.addPrefixPath(path, handler);
            handlers.put(path, handler);
            handlerString = null;
            return this;
        } finally {
            lock.unlock();
        }
    }

    private void setupServiceRegistry() throws Exception {
        Map<String, ServiceRegistry> serviceRegistries = getContext().getRegistry().findByTypeWithName(ServiceRegistry.class);
        if (serviceRegistries != null && !serviceRegistries.isEmpty()) {
            for (Entry<String, ServiceRegistry> entry : serviceRegistries.entrySet()) {
                ServiceRegistry service = entry.getValue();

                if (service.getId() == null) {
                    service.setGeneratedId(getContext().getUuidGenerator().generateUuid());
                }

                LOG.info("Using ServiceRegistry with id: {} and implementation: {}", service.getId(), service);
                getContext().addService(service);
            }
        }
    }

    private void generateUploadUrl(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException {
        GenerateUploadUrlResponse response = null;
        if (getConfiguration().isPojoRequest()) {
            GenerateUploadUrlRequest request = exchange.getIn().getMandatoryBody(GenerateUploadUrlRequest.class);
            response = client.generateUploadUrl(request);
        } else {
            LocationName locationName = LocationName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation());
            GenerateUploadUrlRequest request = GenerateUploadUrlRequest.newBuilder().setParent(locationName.toString())
                    .build();
            response = client.generateUploadUrl(request);
        }
        Message message = getMessageForResponse(exchange);
        message.setHeader(GoogleCloudFunctionsConstants.RESPONSE_OBJECT, response);
        message.setBody(response.getUploadUrl());
    }

    private RedeliveryPolicy resolveRedeliveryPolicy(DefaultErrorHandlerDefinition definition, CamelContext camelContext) {
        if (definition.hasRedeliveryPolicy() && definition.getRedeliveryPolicyRef() != null) {
            throw new IllegalArgumentException(
                    "Cannot have both redeliveryPolicy and redeliveryPolicyRef set at the same time.");
        }

        RedeliveryPolicy answer = null;
        RedeliveryPolicyDefinition def = definition.hasRedeliveryPolicy() ? definition.getRedeliveryPolicy() : null;
        if (def != null) {
            answer = ErrorHandlerReifier.createRedeliveryPolicy(def, camelContext, null);
        }
        if (def == null && definition.getRedeliveryPolicyRef() != null) {
            answer = mandatoryLookup(definition.getRedeliveryPolicyRef(), RedeliveryPolicy.class);
        }
        if (answer == null) {
            answer = RedeliveryPolicy.DEFAULT_POLICY;
        }
        return answer;
    }

    protected void unInitReplyManager() {
        try {
            if (replyManager != null) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Stopping JmsReplyManager: {} from processing replies from: {}", replyManager,
                            endpoint.getReplyTo() != null ? endpoint.getReplyTo() : "temporary queue");
                }
                ServiceHelper.stopService(replyManager);
            }
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        } finally {
            started.set(false);
        }
    }

    private void updateFunction(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException, InterruptedException, ExecutionException {
        CloudFunction response = null;
        if (getConfiguration().isPojoRequest()) {
            UpdateFunctionRequest request = exchange.getIn().getMandatoryBody(UpdateFunctionRequest.class);
            response = client.updateFunctionAsync(request).get();
        } else {
            throw new IllegalArgumentException("updateFunction is supported only in pojo mode");
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(response);
    }

    private void updatePids(Map<Long, Pid> rows) {
        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        Pid row = new Pid();
                        row.pid = Long.toString(ph.pid());
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        int len = row.name.length();
                        if (len < NAME_MIN_WIDTH) {
                            len = NAME_MIN_WIDTH;
                        }
                        if (len > NAME_MAX_WIDTH) {
                            len = NAME_MAX_WIDTH;
                        }
                        if (len > nameMaxWidth) {
                            nameMaxWidth = len;
                        }
                        if (!rows.containsKey(ph.pid())) {
                            rows.put(ph.pid(), row);
                        }
                    }
                });

         
        Set<Long> remove = new HashSet<>();
        for (long pid : rows.keySet()) {
            if (!pids.contains(pid)) {
                remove.add(pid);
            }
        }
        for (long pid : remove) {
            rows.remove(pid);
        }
    }

    protected void findPackages(Set<String> packages, ClassLoader classLoader) throws IOException {
        Enumeration<URL> resources = classLoader.getResources(META_INF_SERVICES);
        while (resources.hasMoreElements()) {
            URL url = resources.nextElement();
            String path = url.getPath();
            if (!visitedURIs.contains(path)) {
                 
                visitedURIs.add(path);
                LOG.debug("Loading file {} to retrieve list of packages, from url: {}", META_INF_SERVICES, url);
                try (BufferedReader reader
                        = IOHelper.buffered(new InputStreamReader(url.openStream(), StandardCharsets.UTF_8))) {
                    while (true) {
                        String line = reader.readLine();
                        if (line == null) {
                            break;
                        }
                        line = line.trim();
                        if (line.startsWith("#") || line.isEmpty()) {
                            continue;
                        }
                        packages.add(line);
                    }
                }
            }
        }
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (getCamelContext().getPropertiesComponent().hasPropertiesFunction("secret")) {
            PropertiesFunction pf = getCamelContext().getPropertiesComponent().getPropertiesFunction("secret");
            if (pf instanceof SecretPropertiesFunction) {
                propertiesFunction = (SecretPropertiesFunction) pf;
            }
        }
        KubernetesVaultConfiguration kubernetes = getCamelContext().getVaultConfiguration().getKubernetesVaultConfiguration();
        if (kubernetes != null && kubernetes.isRefreshEnabled()) {
            PeriodTaskScheduler scheduler = PluginHelper.getPeriodTaskScheduler(getCamelContext());
            secretsRefreshTask = scheduler.getTaskByType(SecretsReloadTriggerTask.class);
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        ElasticsearchConfiguration config = new ElasticsearchConfiguration();
        config.setHostAddresses(this.getHostAddresses());
        config.setSocketTimeout(this.getSocketTimeout());
        config.setMaxRetryTimeout(this.getMaxRetryTimeout());
        config.setConnectionTimeout(this.getConnectionTimeout());
        config.setUser(this.getUser());
        config.setEnableSSL(this.isEnableSSL());
        config.setPassword(this.getPassword());
        config.setCertificatePath(this.getCertificatePath());
        config.setEnableSniffer(this.isEnableSniffer());
        config.setSnifferInterval(this.getSnifferInterval());
        config.setSniffAfterFailureDelay(this.getSniffAfterFailureDelay());
        config.setClusterName(remaining);
        config.setEnableDocumentOnlyMode(this.isEnableDocumentOnlyMode());

        Endpoint endpoint = new ElasticsearchEndpoint(uri, this, config, client);
        setProperties(endpoint, parameters);
        config.setHostAddressesList(parseHostAddresses(config.getHostAddresses(), config));

        return endpoint;
    }

    public static Object[] toArray(Object object) {
        if (object instanceof Collection) {
            return ((Collection<?>) object).toArray();
        } else {
            Object[] answer;
            if (object == null) {
                answer = new Object[0];
            } else {
                answer = new Object[1];
                answer[0] = object;
            }
            return answer;
        }
    }

    protected Marshaller createMarshaller() throws JAXBException {
        Marshaller marshaller = getContext().createMarshaller();
        if (schema != null) {
            marshaller.setSchema(cachedSchema);
            marshaller.setEventHandler((ValidationEvent event) -> {
                 
                return event.getSeverity() < getSchemaSeverityLevel();
            });
        }

        return marshaller;
    }

    private void createUser(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof UserRepresentation) {
                Response response = keycloakClient.realm(realmName).users().create((UserRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            UserRepresentation user = new UserRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USERNAME))) {
                String username = exchange.getIn().getHeader(KeycloakConstants.USERNAME, String.class);
                user.setUsername(username);
                user.setEnabled(true);

                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL))) {
                    user.setEmail(exchange.getIn().getHeader(KeycloakConstants.USER_EMAIL, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME))) {
                    user.setFirstName(exchange.getIn().getHeader(KeycloakConstants.USER_FIRST_NAME, String.class));
                }
                if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME))) {
                    user.setLastName(exchange.getIn().getHeader(KeycloakConstants.USER_LAST_NAME, String.class));
                }
            } else {
                throw new IllegalArgumentException(MISSING_USER_NAME);
            }
            Response response = keycloakClient.realm(realmName).users().create(user);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        SolrConfiguration config = new SolrConfiguration();
        config.setSolrClient(this.getSolrClient());
        config.setHost(this.getHost());
        config.setPort(this.getPort());
        config.setCollection(this.getDefaultCollection());
        config.setRequestTimeout(this.getRequestTimeout());
        config.setConnectionTimeout(this.getConnectionTimeout());
        config.setEnableSSL(this.isEnableSSL());
        config.setUsername(this.getUsername());
        config.setPassword(this.getPassword());
        config.configure(uri);

        Endpoint endpoint = new SolrEndpoint(uri, this, config);
        setProperties(endpoint, parameters);

         
         
        if (config.getCollection() == null && config.getSolrClient() != null) {
            config.setCollection(config.getSolrClient().getDefaultCollection());
        }

        return endpoint;
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, org.apache.pdfbox.pdmodel.PDDocument.class, byte[].class, false,
            (type, exchange, value) -> {
                Object answer = getPdfConverter().convertToPDF((byte[]) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.pdfbox.pdmodel.PDDocument.class, java.io.File.class, false,
            (type, exchange, value) -> {
                Object answer = getPdfConverter().convertToPDF((java.io.File) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, org.apache.pdfbox.pdmodel.PDDocument.class, java.io.InputStream.class, false,
            (type, exchange, value) -> {
                Object answer = getPdfConverter().toPDDocument((java.io.InputStream) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        if (ObjectHelper.isEmpty(remaining)) {
            throw new IllegalArgumentException(
                    "Tool ID must be configured on the endpoint using syntax spring-ai-tools:toolId");
        }

        final String toolId = remaining;
        final String tagList = parameters.get("tags").toString();
        if (ObjectHelper.isEmpty(tagList)) {
            throw new IllegalArgumentException("At least one tag must be specified");
        }

        SpringAiToolsConfiguration springAiToolsConfiguration = this.configuration.copy();

        Map<String, Object> toolParameters = PropertiesHelper.extractProperties(parameters, "parameter.");
        SpringAiToolsEndpoint endpoint
                = new SpringAiToolsEndpoint(uri, this, toolId, tagList, springAiToolsConfiguration);
        endpoint.setParameters(toolParameters.entrySet().stream()
                .collect(Collectors.toMap(Map.Entry::getKey, e -> (String) e.getValue())));

        setProperties(endpoint, parameters);
        return endpoint;
    }

    private static Object asDefaultValue(String type, String defaultValue) {
        if (defaultValue != null) {
            if ("boolean".equals(type)) {
                return Boolean.parseBoolean(defaultValue);
            } else if ("integer".equals(type)) {
                return Integer.parseInt(defaultValue);
            }
        }
        if (defaultValue == null && "boolean".equals(type)) {
            return "false";
        }
        return defaultValue;
    }

    private void setupCustomTypeConverters() {
        Map<String, TypeConverters> typeConverters = getContext().getRegistry().findByTypeWithName(TypeConverters.class);
        if (typeConverters != null && !typeConverters.isEmpty()) {
            for (Entry<String, TypeConverters> entry : typeConverters.entrySet()) {
                TypeConverters converter = entry.getValue();
                LOG.info("Adding custom TypeConverters with id: {} and implementation: {}", entry.getKey(), converter);
                getContext().getTypeConverterRegistry().addTypeConverters(converter);
            }
        }
    }

    public void removeConsumer(String key, KameletConsumer consumer) {
        consumersLock.lock();
        try {
            consumers.remove(key, consumer);
             
            stateCounter++;
            consumersCondition.signalAll();
        } finally {
            consumersLock.unlock();
        }
    }

    protected void doList(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ServiceList servicesList;

        if (ObjectHelper.isEmpty(namespace)) {
            servicesList = getEndpoint().getKubernetesClient().services().inAnyNamespace().list();
        } else {
            servicesList = getEndpoint().getKubernetesClient().services().inNamespace(namespace).list();
        }
        prepareOutboundMessage(exchange, servicesList.getItems());
    }

    private static GenericFileExclusiveReadLockStrategy<FTPFile> getExclusiveReadLockStrategy(Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<FTPFile> strategy
                = (GenericFileExclusiveReadLockStrategy<FTPFile>) params.get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<FTPFile> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                FtpChangedExclusiveReadLockStrategy readLockStrategy = new FtpChangedExclusiveReadLockStrategy();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            }
        }

        return null;
    }

    private GoogleCalendarApiCollection() {
        final Map<String, String> aliases = new HashMap<>();
        final Map<GoogleCalendarApiName, ApiMethodHelper<? extends ApiMethod>> apiHelpers = new EnumMap<>(GoogleCalendarApiName.class);
        final Map<Class<? extends ApiMethod>, GoogleCalendarApiName> apiMethods = new HashMap<>();

        List<String> nullableArgs;

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.ACL, new ApiMethodHelper<>(CalendarAclApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarAclApiMethod.class, GoogleCalendarApiName.ACL);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.LIST, new ApiMethodHelper<>(CalendarCalendarListApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarCalendarListApiMethod.class, GoogleCalendarApiName.LIST);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.CALENDARS, new ApiMethodHelper<>(CalendarCalendarsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarCalendarsApiMethod.class, GoogleCalendarApiName.CALENDARS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.CHANNELS, new ApiMethodHelper<>(CalendarChannelsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarChannelsApiMethod.class, GoogleCalendarApiName.CHANNELS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.COLORS, new ApiMethodHelper<>(CalendarColorsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarColorsApiMethod.class, GoogleCalendarApiName.COLORS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.FREEBUSY, new ApiMethodHelper<>(CalendarFreebusyApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarFreebusyApiMethod.class, GoogleCalendarApiName.FREEBUSY);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.EVENTS, new ApiMethodHelper<>(CalendarEventsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarEventsApiMethod.class, GoogleCalendarApiName.EVENTS);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(GoogleCalendarApiName.SETTINGS, new ApiMethodHelper<>(CalendarSettingsApiMethod.class, aliases, nullableArgs));
        apiMethods.put(CalendarSettingsApiMethod.class, GoogleCalendarApiName.SETTINGS);

        setApiHelpers(apiHelpers);
        setApiMethods(apiMethods);
    }

    protected void doShowTags(Exchange exchange, String operation) throws GitAPIException {
        List<Ref> result = null;
        try {
            result = git.tagList().call();
        } catch (GitAPIException e) {
            LOG.error("There was an error in Git {} operation", operation);
            throw e;
        }
        updateExchange(exchange, result);
    }

    public void pre(SpanAdapter span, Exchange exchange, Endpoint endpoint) {
        super.pre(span, exchange, endpoint);

        String contentType = exchange.getIn().getHeader(CONTENT_TYPE, String.class);
        if (contentType != null) {
            span.setTag(SERVICEBUS_CONTENT_TYPE, contentType);
        }

        String correlationId = exchange.getIn().getHeader(CORRELATION_ID, String.class);
        if (correlationId != null) {
            span.setTag(SERVICEBUS_CORRELATION_ID, correlationId);
        }

        Long deliveryCount = exchange.getIn().getHeader(DELIVERY_COUNT, Long.class);
        if (deliveryCount != null) {
            span.setTag(SERVICEBUS_DELIVERY_COUNT, deliveryCount);
        }

        Long enqueuedSequenceNumber = exchange.getIn().getHeader(ENQUEUED_SEQUENCE_NUMBER, Long.class);
        if (enqueuedSequenceNumber != null) {
            span.setTag(SERVICEBUS_ENQUEUED_SEQUENCE_NUMBER, enqueuedSequenceNumber);
        }

        OffsetDateTime enqueuedTime = exchange.getIn().getHeader(ENQUEUED_TIME, OffsetDateTime.class);
        if (enqueuedTime != null) {
            span.setTag(SERVICEBUS_ENQUEUED_TIME, enqueuedTime.toString());
        }

        OffsetDateTime expiresAt = exchange.getIn().getHeader(EXPIRES_AT, OffsetDateTime.class);
        if (expiresAt != null) {
            span.setTag(SERVICEBUS_EXPIRES_AT, expiresAt.toString());
        }

        String partitionKey = exchange.getIn().getHeader(PARTITION_KEY, String.class);
        if (partitionKey != null) {
            span.setTag(SERVICEBUS_PARTITION_KEY, partitionKey);
        }

        String replyToSessionId = exchange.getIn().getHeader(REPLY_TO_SESSION_ID, String.class);
        if (replyToSessionId != null) {
            span.setTag(SERVICEBUS_REPLY_TO_SESSION_ID, replyToSessionId);
        }

        String sessionId = exchange.getIn().getHeader(SESSION_ID, String.class);
        if (sessionId != null) {
            span.setTag(SERVICEBUS_SESSION_ID, sessionId);
        }

        Duration timeToLive = exchange.getIn().getHeader(TIME_TO_LIVE, Duration.class);
        if (timeToLive != null) {
            span.setTag(SERVICEBUS_TIME_TO_LIVE, timeToLive.toString());
        }
    }

    public V putIfAbsent(K key, V value) {
        if (key == null || value == null) {
            throw new NullPointerException();
        }
        try (OperationContext<K, V> context = new OperationContext<>(this, key)) {
            delegate.compute(
                    key,
                    (k, v) -> {
                        context.result = extractValue(v);
                        if (v != null) {
                            return v;
                        }
                        return addChange(context, x -> value);
                    });
            return context.result;
        }
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    List<Row> collectRows() {
        List<Row> rows = new ArrayList<>();
        for (String name : catalog.findLanguageNames()) {
            LanguageModel model = catalog.languageModel(name);
            if (model != null) {
                Row row = new Row();
                row.name = model.getName();
                row.title = model.getTitle();
                row.level = model.getSupportLevel().name();
                row.since = fixQuarkusSince(model.getFirstVersionShort());
                row.description = model.getDescription();
                row.label = model.getLabel() != null ? model.getLabel() : "";
                row.deprecated = model.isDeprecated();
                row.nativeSupported = model.isNativeSupported();
                row.gav = getGAV(model);
                rows.add(row);
            }
        }
        return rows;
    }

    public Object getInstance(Message m) {
        Object result = null;
        if (provider != null) {
            result = provider.getInstance(m);
        } else {
             
            result = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[] { clazz },
                    new SubResourceClassInvocationHandler());
        }
        return result;
    }

    Resilience4jConfigurationDefinition buildResilience4jConfiguration() throws Exception {
        Map<String, Object> properties = new HashMap<>();

        final PropertyConfigurer configurer = PluginHelper.getConfigurerResolver(camelContext)
                .resolvePropertyConfigurer(Resilience4jConfigurationDefinition.class.getName(), camelContext);

         
         
        loadProperties(properties, Suppliers.firstNotNull(
                () -> camelContext.getCamelContextExtension().getContextPlugin(Model.class).getResilience4jConfiguration(null),
                () -> lookupByNameAndType(ResilienceConstants.DEFAULT_RESILIENCE_CONFIGURATION_ID,
                        Resilience4jConfigurationDefinition.class)),
                configurer);

         
         
        if (definition.getConfiguration() != null) {
            final String ref = parseString(definition.getConfiguration());
            loadProperties(properties, Suppliers.firstNotNull(
                    () -> camelContext.getCamelContextExtension().getContextPlugin(Model.class)
                            .getResilience4jConfiguration(ref),
                    () -> mandatoryLookup(ref, Resilience4jConfigurationDefinition.class)),
                    configurer);
        }

         
        loadProperties(properties, Optional.ofNullable(definition.getResilience4jConfiguration()), configurer);

         
        Resilience4jConfigurationDefinition config = new Resilience4jConfigurationDefinition();
        PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withIgnoreCase(true)
                .withConfigurer(configurer)
                .withProperties(properties)
                .withTarget(config)
                .bind();

        return config;
    }

    public void execute() throws MojoExecutionException, MojoFailureException {
        if (!mainJsonFile.exists()) {
             
            return;
        }

        File file = new File(docDocDir, "main.adoc");
        boolean exists = file.exists();
        boolean updated;
        try {
            String json = PackageHelper.loadText(mainJsonFile);
            MainModel model = JsonMapper.generateMainModel(json);
            String options = evaluateTemplate("main-options.mvel", model);
            updated = updateOptionsIn(file, "main", options);
        } catch (IOException e) {
            throw new MojoExecutionException("Error preparing main docs", e);
        }

        if (updated) {
            getLog().info("Updated doc file: " + file);
        } else if (exists) {
            if (getLog().isDebugEnabled()) {
                getLog().debug("No changes to doc file: " + file);
            }
        } else {
            getLog().warn("No main doc file: " + file);
        }
    }

    public Processor createPreProcessor(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        if (exchange.getMessage().getHeader(PahoMqtt5Constants.CAMEL_PAHO_OVERRIDE_TOPIC) != null) {
            return null;
        }

        final String destinationName = parseTopicName(entry.getUri());
        return new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
                exchange.getMessage().setHeader(PahoMqtt5Constants.CAMEL_PAHO_OVERRIDE_TOPIC, destinationName);
            }
        };
    }

    private void userSelectedPropertiesMDC(Exchange exchange, boolean push) {
        for (String customProperty : getCustomProperties().split(",")) {
            if (exchange.getProperty(customProperty) != null) {
                if (push) {
                    MDC.put(customProperty, exchange.getProperty(customProperty, String.class));
                } else {
                    MDC.remove(customProperty);
                }
            }
        }
    }

    protected String getEndpointUri(Row r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumMongodbComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumMongodbComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumMongodbComponent) component).setConfiguration((org.apache.camel.component.debezium.mongodb.configuration.MongoDbConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumMongodbComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumMongodbComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumMongodbComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "captureMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCaptureMode((java.lang.String) value); return true;
            case "collectionExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCollectionExcludeList((java.lang.String) value); return true;
            case "collectionIncludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCollectionIncludeList((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumMongodbComponent) component).setConverters((java.lang.String) value); return true;
            case "cursorMaxAwaitTimeMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCursorMaxAwaitTimeMs((int) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setDatabaseExcludeList((java.lang.String) value); return true;
            case "databaseIncludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setDatabaseIncludeList((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumMongodbComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "fieldExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setFieldExcludeList((java.lang.String) value); return true;
            case "fieldRenames": getOrCreateConfiguration((DebeziumMongodbComponent) component).setFieldRenames((java.lang.String) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumMongodbComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumMongodbComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumMongodbComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "mongodbAuthsource": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbAuthsource((java.lang.String) value); return true;
            case "mongodbConnectionString": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbConnectionString((java.lang.String) value); return true;
            case "mongodbConnectTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbConnectTimeoutMs((int) value); return true;
            case "mongodbHeartbeatFrequencyMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbHeartbeatFrequencyMs((int) value); return true;
            case "mongodbPassword": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbPassword((java.lang.String) value); return true;
            case "mongodbPollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbPollIntervalMs((long) value); return true;
            case "mongodbServerSelectionTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbServerSelectionTimeoutMs((int) value); return true;
            case "mongodbSocketTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSocketTimeoutMs((int) value); return true;
            case "mongodbSslEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSslEnabled((boolean) value); return true;
            case "mongodbSslInvalidHostnameAllowed": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSslInvalidHostnameAllowed((boolean) value); return true;
            case "mongodbUser": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbUser((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumMongodbComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumMongodbComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumMongodbComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setQueryFetchSize((int) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotCollectionFilterOverrides": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotCollectionFilterOverrides((java.lang.String) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setStreamingDelayMs((long) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            default: return false;
            }
        }

    public String extractCompletionReason(String chunk) throws JsonProcessingException {
        if (chunk == null || chunk.trim().isEmpty()) {
            return null;
        }
        JsonNode node = MAPPER.readTree(chunk);
        JsonNode type = node.get("type");

        if (type != null && "message_delta".equals(type.asText())) {
            JsonNode delta = node.get("delta");
            if (delta != null) {
                JsonNode stopReason = delta.get("stop_reason");
                return stopReason != null && !stopReason.isNull() ? stopReason.asText() : null;
            }
        }
        return null;
    }

    public Calendar getClient(GoogleCalendarStreamConfiguration config) {
        if (client == null) {
            if (config.getClientId() != null && config.getClientSecret() != null) {
                client = getClientFactory().makeClient(config.getClientId(), config.getClientSecret(), config.getScopesAsList(),
                        config.getApplicationName(), config.getRefreshToken(),
                        config.getAccessToken(), config.getEmailAddress(), config.getP12FileName(), config.getUser());
            } else if (config.getServiceAccountKey() != null) {
                client = getClientFactory().makeClient(getCamelContext(), config.getServiceAccountKey(),
                        config.getScopesAsList(),
                        config.getApplicationName(), config.getDelegate());
            } else {
                throw new IllegalArgumentException(
                        "(clientId and clientSecret) or serviceAccountKey are required to create Gmail client");
            }
        }
        return client;
    }

    public void setCertificateName(String certificateName) {
        if (context != null && certificateName != null) {
            Certificate certificate = context.getRegistry().lookupByNameAndType(certificateName, Certificate.class);
            if (certificate != null) {
                setCertificate(certificate);
            }
        }
        if (certificateName != null) {
            this.certificateName = certificateName;
        }
    }

    public int forceDiscardingOfGroup(String key) {
         
        int total = 0;

        lock.lock();
        try {
            Exchange exchange = aggregationRepository.get(camelContext, key);
            if (exchange != null) {
                total = 1;
                LOG.trace("Force discarded triggered for correlation key: {}", key);
                 
                onCompletion(key, exchange, exchange, false, true);
            }
        } finally {
            lock.unlock();
        }
        LOG.trace("Completed force discarded of group {}", key);

        if (total > 0) {
            LOG.debug("Forcing discarding of group {} with {} exchanges", key, total);
        }
        return total;
    }

    public KeyPair rotateKey(String oldKeyId, String newKeyId, String algorithm) throws Exception {
        LOG.info("Rotating key from {} to {}", oldKeyId, newKeyId);

         
        KeyMetadata oldMetadata = getKeyMetadata(oldKeyId);
        if (oldMetadata == null) {
            throw new IllegalArgumentException("Old key not found: " + oldKeyId);
        }

         
        oldMetadata.setStatus(KeyMetadata.KeyStatus.DEPRECATED);
        updateKeyMetadata(oldKeyId, oldMetadata);

         
        KeyPair newKeyPair = generateKeyPair(algorithm, newKeyId);

        LOG.info("Key rotation completed in Vault: {} -> {}", oldKeyId, newKeyId);
        return newKeyPair;
    }

    private void processGetFailedResults(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
        bulkClient.getFailedResults(jobId, determineHeaders(exchange),
                new StreamResponseCallback() {
                    @Override
                    public void onResponse(
                            InputStream inputStream, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, inputStream, headers, ex, callback);
                    }
                });
    }

    protected void scheduleDelayedStart() {
        Runnable startRunnable = new Runnable() {
            @Override
            public void run() {
                try {
                    doStart();
                } catch (Exception e) {
                    LOG.warn("Ignoring an exception caught in the startup connection poller thread.", e);
                }
            }
        };
        LOG.info("Delaying XMPP consumer startup for endpoint {}. Trying again in {} seconds.",
                URISupport.sanitizeUri(endpoint.getEndpointUri()), endpoint.getConnectionPollDelay());
        getExecutor().schedule(startRunnable, endpoint.getConnectionPollDelay(), TimeUnit.SECONDS);
    }

    protected String doCallText(Map<String, Object> options) {
        StringBuilder sb = new StringBuilder();

        if (rr != null) {
            for (RestRegistry.RestService rs : rr.listAllRestServices()) {
                if (!sb.isEmpty()) {
                    sb.append("\n");
                }
                sb.append(String.format("\n    Url: %s", rs.getUrl()));
                sb.append(String.format("\n    Method: %s", rs.getMethod()));
                sb.append(String.format("\n    State: %s", rs.getState()));
                if (rs.getConsumes() != null) {
                    sb.append(String.format("\n    Consumes: %s", rs.getConsumes()));
                }
                if (rs.getProduces() != null) {
                    sb.append(String.format("\n    Produces: %s", rs.getProduces()));
                }
                if (rs.getInType() != null) {
                    sb.append(String.format("\n    In Type: %s", rs.getInType()));
                }
                if (rs.getOutType() != null) {
                    sb.append(String.format("\n    Out Type: %s", rs.getOutType()));
                }
                if (rs.getDescription() != null) {
                    sb.append(String.format("\n    Description: %s", rs.getDescription()));
                }
            }
            sb.append("\n");
        }

        return sb.toString();
    }

    private void doCreateOrUpdateNode(Exchange exchange, String operationName, Function<Resource<Node>, Node> operation) {
        String nodeName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NODE_NAME, String.class);
        NodeSpec nodeSpec = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NODE_SPEC, NodeSpec.class);
        if (ObjectHelper.isEmpty(nodeName)) {
            LOG.error("{} a specific node require specify a node name", operationName);
            throw new IllegalArgumentException(String.format("%s a specific node require specify a node name", operationName));
        }
        if (ObjectHelper.isEmpty(nodeSpec)) {
            LOG.error("{} a specific node require specify a node spec bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific node require specify a node spec bean", operationName));
        }
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PODS_LABELS, Map.class);
        Node nodeCreating = new NodeBuilder().withNewMetadata().withName(nodeName).withLabels(labels).endMetadata()
                .withSpec(nodeSpec).build();
        Node node = operation.apply(getEndpoint().getKubernetesClient().nodes().resource(nodeCreating));

        prepareOutboundMessage(exchange, node);
    }

    public static boolean hasAnnotation(Class<?> cls, Class<? extends Annotation> annotation) {
        if (cls == null || cls == Object.class) {
            return false;
        }

        if (null != cls.getAnnotation(annotation)) {
            return true;
        }

        for (Class<?> interfaceClass : cls.getInterfaces()) {
            if (null != interfaceClass.getAnnotation(annotation)) {
                return true;
            }
        }
        return hasAnnotation(cls.getSuperclass(), annotation);
    }

    protected DataSetCallback resolveDataSetCallback(Exchange exchange) {
        if (exchange.getIn().getHeader(FlinkConstants.FLINK_DATASET_CALLBACK_HEADER) != null) {
            return (DataSetCallback) exchange.getIn().getHeader(FlinkConstants.FLINK_DATASET_CALLBACK_HEADER);
        } else if (getEndpoint().getDataSetCallback() != null) {
            return getEndpoint().getDataSetCallback();
        } else {
            throw new IllegalStateException("Cannot resolve DataSet callback.");
        }
    }

    public CamelMessageReceiver(GooglePubsubConsumer consumer, GooglePubsubEndpoint endpoint, Processor processor) {
        this.consumer = consumer;
        this.endpoint = endpoint;
        this.processor = processor;
        String loggerId = endpoint.getLoggerId();
        if (Strings.isNullOrEmpty(loggerId)) {
            loggerId = this.getClass().getName();
        }
        localLog = LoggerFactory.getLogger(loggerId);
        headerFilterStrategy = endpoint.getHeaderFilterStrategy();
    }

        public ComponentCustomizer build(ThrowingBiConsumer<String, T, Exception> consumer) {
            final int order = this.order;
            final BiPredicate<String, Component> condition = condition();

            return new ComponentCustomizer() {
                @SuppressWarnings("unchecked")
                @Override
                public void configure(String name, Component target) {
                    ObjectHelper.notNull(name, "component name");
                    ObjectHelper.notNull(target, "component instance");

                    try {
                        consumer.accept(name, (T) target);
                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }
                }

                @Override
                public boolean isEnabled(String name, Component target) {
                    ObjectHelper.notNull(name, "component name");
                    ObjectHelper.notNull(target, "component instance");

                    return condition.test(name, target);
                }

                @Override
                public int getOrder() {
                    return order;
                }
            };
        }

    public void getAllQueryJobs(
            String queryLocator, Map<String, List<String>> headers, QueryJobsResponseCallback callback) {
        String url = queryJobUrl(null);
        if (queryLocator != null) {
            url = url + "?queryLocator=" + queryLocator;
        }
        final Request request = getRequest(HttpMethod.GET, url, headers);
        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> responseHeaders, SalesforceException ex) {
                if (ex != null) {
                    callback.onResponse(null, responseHeaders, ex);
                    return;
                }
                QueryJobs responseJobs = null;
                try {
                    responseJobs = unmarshalResponse(response, request, QueryJobs.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(responseJobs, responseHeaders, ex);
            }
        });
    }

    private CachingInjector<?> handleHasFallbackConverterAnnotation(
            TypeConverterRegistry registry, Class<?> type,
            CachingInjector<?> injector, Method method, boolean allowNull) {
        if (isValidFallbackConverterMethod(method)) {
            int modifiers = method.getModifiers();
            if (isAbstract(modifiers) || !isPublic(modifiers)) {
                LOG.warn("Ignoring bad fallback converter on type: {} method: {} as a fallback converter method is not "
                         + "a public and concrete method",
                        type.getCanonicalName(), method);
            } else {
                Class<?> toType = method.getReturnType();
                if (toType.equals(Void.class)) {
                    LOG.warn("Ignoring bad fallback converter on type: {} method: {} as a fallback converter method "
                             + "returns a void method",
                            type.getCanonicalName(), method);
                } else {
                    if (isStatic(modifiers)) {
                        registerFallbackTypeConverter(registry,
                                new StaticMethodFallbackTypeConverter(method, registry, allowNull), method);
                    } else {
                        if (injector == null) {
                            injector = new CachingInjector<>(registry, CastUtils.cast(type, Object.class));
                        }
                        registerFallbackTypeConverter(registry,
                                new InstanceMethodFallbackTypeConverter(injector, method, registry, allowNull), method);
                    }
                }
            }
        } else {
            LOG.warn("Ignoring bad fallback converter on type: {} method: {} as a fallback converter method should have "
                     + "one parameter",
                    type.getCanonicalName(), method);
        }
        return injector;
    }

    private static ActiveMQMessage createActiveMQMessage(Exchange exchange) throws JMSException {
        Object body = exchange.getIn().getBody();
        if (body instanceof String) {
            ActiveMQTextMessage answer = new ActiveMQTextMessage();
            answer.setText((String) body);
            return answer;
        } else if (body instanceof Serializable) {
            ActiveMQObjectMessage answer = new ActiveMQObjectMessage();
            answer.setObject((Serializable) body);
            return answer;
        } else {
            return new ActiveMQMessage();
        }

    }

    public Short getShort(final int index) {
        Object returnable = this.get(index);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).shortValue();
    }

    private String getId(SuspendedRow r) {
        if (r.first) {
            return "*-->";
        } else if (r.last) {
            return "*<--";
        } else {
            return r.nodeId;
        }
    }

    protected void doStop() throws Exception {
        if (connection != null) {
            for (IrcChannel channel : endpoint.getConfiguration().getChannelList()) {
                LOG.debug("Parting: {}", channel);
                connection.doPart(channel.getName());
            }
            connection.removeIRCEventListener(listener);
        }
        super.doStop();
    }

    private List<SplunkEvent> nonBlockingSearch(SplunkResultProcessor callback) throws Exception {
        LOG.debug("non block search start");

        JobArgs queryArgs = new JobArgs();
        queryArgs.setExecutionMode(ExecutionMode.NORMAL);
        Calendar startTime = Calendar.getInstance();
        populateArgs(queryArgs, startTime, false);

        List<SplunkEvent> data = runQuery(queryArgs, false, callback);
        lastSuccessfulReadTime = startTime;
        return data;
    }

    protected void printSource(List<Row> rows) {
        for (Row row : rows) {
            printer().println();
            if (!raw) {
                printer().printf("Source: %s%n", row.location);
                printer().println("--------------------------------------------------------------------------------");
            }
            for (int i = 0; i < row.code.size(); i++) {
                Code code = row.code.get(i);
                String c = Jsoner.unescape(code.code);
                if (raw) {
                    printer().printf("%s%n", c);
                } else {
                    if (code.line != -1) {
                        printer().printf("%4d: %s%n", code.line, c);
                    } else {
                        printer().printf("      %s%n", c);
                    }
                }
            }
            printer().println();
        }
    }

    private void processCreateJob(Exchange exchange, AsyncCallback callback)
            throws InvalidPayloadException {
        Job job = exchange.getIn().getMandatoryBody(Job.class);
        bulkClient.createJob(job, determineHeaders(exchange),
                new JobResponseCallback() {
                    @Override
                    public void onResponse(Job job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    private String parseDestinationName(String uri) {
         
        uri = uri.replaceFirst(scheme + "://", ":");
        uri = StringHelper.before(uri, "?", uri);

         
        String shortUri = StringHelper.before(uri, "::");
        final int lastIdx = lastIndexOneOf(uri, shortUri);
        if (lastIdx != -1) {
            return uri.substring(lastIdx + 1);
        } else {
            return null;
        }
    }

    private void describeDeliveryStream(FirehoseClient client, Exchange exchange) throws InvalidPayloadException {
        executeOperation(
                exchange,
                DescribeDeliveryStreamRequest.class,
                client::describeDeliveryStream,
                () -> {
                    String streamName = getOptionalHeader(exchange, KinesisFirehose2Constants.KINESIS_FIREHOSE_STREAM_NAME,
                            String.class);
                    if (streamName == null) {
                        throw new IllegalArgumentException(
                                "The describeDeliveryStream operation expects at least a delivery stream name header or a DescribeDeliveryStreamRequest instance");
                    }
                    return client.describeDeliveryStream(
                            DescribeDeliveryStreamRequest.builder().deliveryStreamName(streamName).build());
                },
                "describeDeliveryStream",
                (DescribeDeliveryStreamResponse response, Message message) -> {
                    if (response.deliveryStreamDescription() != null) {
                        message.setHeader(KinesisFirehose2Constants.DELIVERY_STREAM_ARN,
                                response.deliveryStreamDescription().deliveryStreamARN());
                        message.setHeader(KinesisFirehose2Constants.DELIVERY_STREAM_STATUS,
                                response.deliveryStreamDescription().deliveryStreamStatusAsString());
                    }
                });
    }

    private void userSelectedPropertiesMDC(Exchange exchange, boolean push) {
        for (String customProperty : getCustomProperties().split(",")) {
            if (exchange.getProperty(customProperty) != null) {
                if (push) {
                    MDC.put(customProperty, exchange.getProperty(customProperty, String.class));
                } else {
                    MDC.remove(customProperty);
                }
            }
        }
    }

    public void performStats(final Exchange exchange, AsyncCallback callback) {
        Message message = exchange.getMessage();
        Map<String, Object> headers = message.getHeaders();
        String subscribeChannel = (String) headers.getOrDefault(CONTROL_SUBSCRIBE_CHANNEL, configuration.getSubscribeChannel());
        try {
            String stats = dynamicRouterControlService.getStatisticsForChannel(subscribeChannel);
            message.setBody(stats, String.class);
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
            callback.done(false);
        }
    }

    private void bulkAssignRolesToUser(Keycloak keycloakClient, Exchange exchange) {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String userId = exchange.getIn().getHeader(KeycloakConstants.USER_ID, String.class);
        if (ObjectHelper.isEmpty(userId)) {
            throw new IllegalArgumentException(MISSING_USER_ID);
        }

        List<String> roleNames = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAMES, List.class);
        if (roleNames == null || roleNames.isEmpty()) {
             
            Object payload = exchange.getIn().getBody();
            if (payload instanceof List) {
                roleNames = CastUtils.cast((List<?>) payload);
            } else {
                throw new IllegalArgumentException("Role names must be provided via header or body");
            }
        }

        boolean continueOnError
                = exchange.getIn().getHeader(KeycloakConstants.CONTINUE_ON_ERROR, Boolean.FALSE, Boolean.class);
        List<Map<String, Object>> results = new ArrayList<>();
        List<RoleRepresentation> rolesToAssign = new ArrayList<>();
        int successCount = 0;
        int failureCount = 0;

         
        for (String roleName : roleNames) {
            Map<String, Object> result = new HashMap<>();
            result.put("roleName", roleName);
            try {
                RoleRepresentation role = keycloakClient.realm(realmName).roles().get(roleName).toRepresentation();
                rolesToAssign.add(role);
                result.put("status", "found");
                successCount++;
            } catch (Exception e) {
                result.put("status", "not_found");
                result.put("error", e.getMessage());
                failureCount++;
                if (!continueOnError) {
                    throw new RuntimeException("Failed to find role: " + roleName, e);
                }
            }
            results.add(result);
        }

         
        if (!rolesToAssign.isEmpty()) {
            try {
                keycloakClient.realm(realmName).users().get(userId).roles().realmLevel().add(rolesToAssign);
            } catch (Exception e) {
                throw new RuntimeException("Failed to assign roles to user: " + userId, e);
            }
        }

        Map<String, Object> summary = new HashMap<>();
        summary.put("total", roleNames.size());
        summary.put("success", successCount);
        summary.put("failed", failureCount);
        summary.put("assigned", rolesToAssign.size());
        summary.put("results", results);

        Message message = getMessageForResponse(exchange);
        message.setBody(summary);
    }

    public void connect(HttpConsumer consumer) throws Exception {
         
        JettyHttpEndpoint endpoint = (JettyHttpEndpoint) consumer.getEndpoint();
        String connectorKey = getConnectorKey(endpoint);

        try {
            CONNECTORS.compute(connectorKey, (cKey, connectorRef) -> {
                try {
                    return connect(consumer, endpoint, cKey, connectorRef);
                } catch (Exception e) {
                    throw new RuntimeCamelException(e);
                }
            });
        } catch (RuntimeCamelException e) {
            throw (Exception) e.getCause();
        }
    }

    private Message getNextElement() {
        if (asn1InputStream == null) {
            return null;
        }

        try {
            ASN1Primitive current = getNextEntry();

            if (current != null) {
                Message answer = new DefaultMessage(exchange.getContext());
                answer.getHeaders().putAll(exchange.getIn().getHeaders());
                answer.setBody(current.getEncoded());
                return answer;
            } else {
                LOGGER.trace("close asn1InputStream");
                return null;
            }
        } catch (IOException exception) {
            throw new RuntimeCamelException(exception);
        }
    }

    protected String getSource(Annotation annotation) {
        String answer = null;
        try {
            answer = (String) getAnnotationObjectValue(annotation, "source");
        } catch (Exception e) {
             
        }
        if (answer != null && answer.isBlank()) {
            return null;
        }
        return answer;
    }

    public static void initializeSantuario() {
         
        boolean wasSet = false;
        try {
             
            String lineBreakPropName = "org.apache.xml.security.ignoreLineBreaks";
            if (System.getProperty(lineBreakPropName) == null) {
                System.setProperty(lineBreakPropName, "true");
                wasSet = false;
            } else {
                wasSet = true;
            }
        } catch (Exception t) {
             
        }

        org.apache.xml.security.Init.init();

        if (!wasSet) {
            try {
                Field f = XMLUtils.class.getDeclaredField("ignoreLineBreaks");
                f.setAccessible(true);
                f.set(null, Boolean.TRUE);
            } catch (Exception t) {
                 
            }
        }
    }

    public void process(Exchange exchange) throws Exception {
        Object payload = exchange.getMessage().getBody();
        if (payload == null) {
            return;
        }

        JsonNode answer = computeIfAbsent(exchange);

        if (answer != null) {
            exchange.setProperty(SchemaHelper.CONTENT_SCHEMA, answer);
            exchange.setProperty(SchemaHelper.CONTENT_SCHEMA_TYPE, SchemaType.JSON.type());
            exchange.setProperty(SchemaHelper.CONTENT_CLASS, SchemaHelper.resolveContentClass(exchange, this.contentClass));
        }
    }

    private String extractPlatform(ProcessHandle ph, JsonObject runtime) {
        String answer = runtime != null ? runtime.getString("platform") : null;
        if ("Camel".equals(answer)) {
             
            String cl = ph.info().commandLine().orElse("");
            if (cl.contains("main.CamelJBang run")) {
                answer = "JBang";
            }
        }
        return answer;
    }

    public static Exchange toExchange(
            Consumer consumer, SessionID sessionID, Message message, QuickfixjEventCategory eventCategory,
            ExchangePattern exchangePattern) {
        Exchange exchange = consumer.createExchange(false);
        exchange.setPattern(exchangePattern);

        org.apache.camel.Message camelMessage = exchange.getIn();
        camelMessage.setHeader(EVENT_CATEGORY_KEY, eventCategory);
        camelMessage.setHeader(SESSION_ID_KEY, sessionID);

        if (message != null) {
            try {
                camelMessage.setHeader(MESSAGE_TYPE_KEY, message.getHeader().getString(MsgType.FIELD));
            } catch (FieldNotFound e) {
                LOG.warn("Message type field not found in QFJ message: {}, continuing...", message);
            }
        }
        camelMessage.setBody(message);

        return exchange;
    }

    public static Object deserializeJavaObjectFromStream(InputStream is) throws ClassNotFoundException, IOException {
        if (is == null) {
            return null;
        }

        Object answer;
        ObjectInputStream ois = new ObjectInputStream(is);
        try {
            answer = ois.readObject();
        } finally {
            IOHelper.close(ois);
        }

        return answer;
    }

    protected void copyAgentDependencies(Set<String> deps) throws Exception {
        for (String d : deps) {
            if (d.startsWith("agent:")) {
                Path libDirPath = Paths.get(BUILD_DIR, "agent");
                Files.createDirectories(libDirPath);
                String n = d.substring(6);
                MavenGav gav = MavenGav.parseGav(n);
                copyAgentLibDependencies(gav);
            }
        }
    }

    protected void outputGav(MavenGav gav, int index, int total) {
        try {
            List<MavenArtifact> artifacts = getDownloader().resolveArtifacts(
                    List.of(gav.toString()), Set.of(), true, gav.getVersion().contains("SNAPSHOT"));
            for (MavenArtifact artifact : artifacts) {
                Path target = Paths.get(outputDirectory, artifact.getFile().getName());
                if (Files.exists(target) || EXCLUDED_GROUP_IDS.contains(artifact.getGav().getGroupId())) {
                    continue;
                }
                Files.copy(artifact.getFile().toPath(), target);
            }
        } catch (MavenResolutionException e) {
            printer().printErr("Error resolving the artifact: " + gav + " due to: " + e.getMessage());
        } catch (IOException e) {
            printer().printErr("Error copying the artifact: " + gav + " due to: " + e.getMessage());
        }
    }

private int jjMoveStringLiteralDfa3_0(long old0, long active0){
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(1, old0);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(2, active0);
      return 3;
   }
   switch(curChar)
   {
      case 32:
         if ((active0 & 0x4L) != 0L)
            return jjStopAtPos(3, 2);
         break;
      case 85:
         return jjMoveStringLiteralDfa4_0(active0, 0x8L);
      default :
         break;
   }
   return jjStartNfa_0(2, active0);
}

    public MessageHistory newMessageHistory(String routeId, NamedNode namedNode, Exchange exchange) {
        if (nodePattern != null) {
            String name = namedNode.getShortName();
            String[] parts = nodePattern.split(",");
            boolean match = false;
            for (String part : parts) {
                if (PatternHelper.matchPattern(name, part)) {
                    match = true;
                    break;
                }
            }
             
            if (!match) {
                return null;
            }
        }

        Message msg = null;
        if (copyMessage) {
            msg = exchange.getMessage().copy();
        }

        Route route = camelContext.getRoute(routeId);
        if (route != null) {
            return new OpenTelemetryMessageHistory(timer, getTimeUnit(), route, namedNode, getNamingStrategy(), msg);
        } else {
            return null;
        }
    }

    protected void doDelete(Exchange exchange, String namespaceName) {
        String customResourceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_CRD_INSTANCE_NAME, String.class);
        if (ObjectHelper.isEmpty(customResourceName)) {
            LOG.error("Deleting a specific custom resource require specify a custom resource name");
            throw new IllegalArgumentException("Deleting a specific custom resource require specify a custom resource name");
        }

        try {
            List<StatusDetails> statusDetails
                    = getEndpoint().getKubernetesClient().genericKubernetesResources(getCRDContext(exchange.getIn()))
                            .inNamespace(namespaceName).withName(customResourceName).delete();

            boolean deleted = ObjectHelper.isNotEmpty(statusDetails);
            exchange.getMessage().setHeader(KubernetesConstants.KUBERNETES_DELETE_RESULT, deleted);
        } catch (KubernetesClientException e) {
            if (e.getCode() == 404) {
                LOG.info("Custom resource instance not found", e);
            } else {
                throw e;
            }
        }

    }

    private void processCreateJob(final Exchange exchange, final AsyncCallback callback)
            throws InvalidPayloadException {
        JobInfo jobBody = exchange.getIn().getMandatoryBody(JobInfo.class);
        bulkClient.createJob(jobBody, determineHeaders(exchange), new BulkApiClient.JobInfoResponseCallback() {
            @Override
            public void onResponse(JobInfo jobInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, jobInfo, headers, ex, callback);
            }
        });
    }

    public static EipModel generateEipModel(JsonObject obj) {
        JsonObject mobj = (JsonObject) obj.get("model");
        EipModel model = new EipModel();
        parseModel(mobj, model);
        model.setAbstractModel(mobj.getBooleanOrDefault("abstract", false));
        model.setInput(mobj.getBooleanOrDefault("input", false));
        model.setOutput(mobj.getBooleanOrDefault("output", false));
        JsonObject mprp = (JsonObject) obj.get("properties");
        if (mprp != null) {
            for (Map.Entry<String, Object> entry : mprp.entrySet()) {
                JsonObject mp = (JsonObject) entry.getValue();
                EipOptionModel option = new EipOptionModel();
                parseOption(mp, option, entry.getKey());
                model.addOption(option);
            }
        }
        mprp = (JsonObject) obj.get("exchangeProperties");
        if (mprp != null) {
            for (Map.Entry<String, Object> entry : mprp.entrySet()) {
                JsonObject mp = (JsonObject) entry.getValue();
                EipOptionModel option = new EipOptionModel();
                parseOption(mp, option, entry.getKey());
                model.addExchangeProperty(option);
            }
        }
        return model;
    }

    public BoxFolder.Info getFolderInfo(String folderId, String... fields) {
        try {
            LOG.debug("Getting info for folder(id={})", folderId);
            BoxHelper.notNull(folderId, FOLDER_ID);

            BoxFolder folder = new BoxFolder(boxConnection, folderId);

            if (fields == null || fields.length == 0) {
                return folder.getInfo();
            } else {
                return folder.getInfo(fields);
            }
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(
                    buildBoxApiErrorMessage(e), e);
        }
    }

    protected String getEndpointUri(StatusRow r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    public static String getType(String type, boolean enumType, boolean isDuration) {
        if (enumType) {
            return "enum";
        } else if (isDuration) {
            return "duration";
        } else if (type == null) {
             
            return "object";
        } else if (type.equals(URI.class.getName()) || type.equals(URL.class.getName())) {
            return "string";
        } else if (type.equals(File.class.getName())) {
            return "string";
        } else if (type.equals(Date.class.getName())) {
            return "string";
        } else if (type.startsWith("java.lang.Class")) {
            return "string";
        } else if (type.startsWith("java.util.List") || type.startsWith("java.util.Collection")) {
            return "array";
        }

        String primitive = getPrimitiveType(type);
        if (primitive != null) {
            return primitive;
        }

        return "object";
    }

    public <T> void read(
            final Edm edm, final String resourcePath, final Map<String, String> queryParams,
            final Map<String, String> endpointHttpHeaders,
            final Olingo2ResponseHandler<T> responseHandler) {

        final UriInfoWithType uriInfo = parseUri(edm, resourcePath, queryParams);

        execute(new HttpGet(createUri(resourcePath, encodeQueryParams(queryParams))), getResourceContentType(uriInfo),
                endpointHttpHeaders,
                new AbstractFutureCallback<T>(responseHandler) {

                    @Override
                    public void onCompleted(HttpResponse result) throws IOException {
                        readContent(uriInfo, headersToMap(result.getAllHeaders()),
                                result.getEntity() != null ? result.getEntity().getContent() : null, responseHandler);
                    }

                });
    }

    public Object copy() {
        try {
            EmbeddedDebeziumConfiguration answer = (EmbeddedDebeziumConfiguration) clone();
             
            Map<String, Object> additionalPropertiesCopy = new HashMap<>(additionalProperties);
            answer.setAdditionalProperties(additionalPropertiesCopy);
            return answer;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeCamelException(e);
        }
    }

    protected boolean isMatched(Supplier<GenericFile<FTPFile>> file, String doneFileName, FTPFile[] files) {
        String onlyName = FileUtil.stripPath(doneFileName);

        for (FTPFile f : files) {
            if (f.getName().equals(onlyName)) {
                return true;
            }
        }

        LOG.trace("Done file: {} does not exist", doneFileName);
        return false;
    }

    public BoxFile moveFile(String fileId, String destinationFolderId, String newName) {
        try {
            LOG.debug("Moving file(id={}) to destination_folder(id={}) {}",
                    fileId, destinationFolderId,
                    newName == null ? "" : " with new name '" + newName + "'");
            BoxHelper.notNull(fileId, BoxHelper.FILE_ID);
            BoxHelper.notNull(destinationFolderId, BoxHelper.VERSION);
            BoxFile fileToMove = new BoxFile(boxConnection, fileId);
            BoxFolder destinationFolder = new BoxFolder(boxConnection, destinationFolderId);
            if (newName == null) {
                return (BoxFile) fileToMove.move(destinationFolder).getResource();
            } else {
                return (BoxFile) fileToMove.move(destinationFolder, newName).getResource();
            }
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(BoxHelper.buildBoxApiErrorMessage(e), e);
        }
    }

    public Optional<CamelClusterMember> getLeader() {
        if (this.cache == null) {
            return Optional.empty();
        }

        String id = cache.get(InfinispanClusterService.LEADER_KEY);
        if (id == null) {
            return Optional.empty();
        }

        return Optional.of(new ClusterMember(id));
    }

    protected void resetPartTypeClass(MessageInfo msgInfo) {
        if (msgInfo != null) {
            int size = msgInfo.getMessageParts().size();
            for (int x = 0; x < size; x++) {
                 
                if (x < (size - 1)) {
                    msgInfo.getMessageParts().get(x).setTypeClass(allowStreaming ? DOMSource.class : null);
                } else {
                    msgInfo.getMessageParts().get(x).setTypeClass(allowStreaming ? Source.class : null);
                }
            }
        }
    }

    private void processGetQueryJob(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        QueryJob job = exchange.getIn().getBody(QueryJob.class);
        String jobId;
        if (job != null) {
            jobId = job.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getQueryJob(jobId, determineHeaders(exchange),
                new BulkApiV2Client.QueryJobResponseCallback() {
                    @Override
                    public void onResponse(QueryJob job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    public String dumpRoutesAsYaml(
            boolean resolvePlaceholders, boolean uriAsParameters, boolean generatedIds, boolean sourceLocation)
            throws Exception {
        List<RouteDefinition> routes = context.getCamelContextExtension().getContextPlugin(Model.class).getRouteDefinitions();
        if (routes.isEmpty()) {
            return null;
        }

         
        RoutesDefinition def = new RoutesDefinition();
        def.setRoutes(routes);

         
        if (context.isDebugging()) {
            generatedIds = true;
        }

        return PluginHelper.getModelToYAMLDumper(context).dumpModelAsYaml(context, def, resolvePlaceholders, uriAsParameters,
                generatedIds, sourceLocation);
    }

    public Short getShort(final int index) {
        Object returnable = this.get(index);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).shortValue();
    }

    public static int compare(String source, String target) {
        if (source == null || target == null) {
            return 0;
        }
        String s1 = StringHelper.before(source, ".");
        String s2 = StringHelper.after(source, ".");
        if (s1 == null) {
            s1 = StringHelper.before(source, ",");
            s2 = StringHelper.after(source, ",");
        }
        String t1 = StringHelper.before(target, ".");
        String t2 = StringHelper.after(target, ".");
        if (t1 == null) {
            t1 = StringHelper.before(target, ",");
            t2 = StringHelper.after(target, ",");
        }
        String s3 = StringHelper.after(s2, ".");
        if (s3 != null) {
            s2 = StringHelper.before(s2, ".");
        } else {
            s3 = "";
        }
        String t3 = StringHelper.after(t2, ".");
        if (t3 != null) {
            t2 = StringHelper.before(t2, ".");
        } else {
            t3 = "";
        }
         
        if (s1 == null) {
            s1 = source;
        }
        if (s2 == null) {
            s2 = "";
        }
        if (t1 == null) {
            t1 = target;
        }
        if (t2 == null) {
            t2 = "";
        }
         
        if (s1.length() < 2) {
            s1 = "0" + s1;
        }
        if (s2.length() < 2) {
            s2 = "0" + s2;
        }
        if (s2.length() < 2) {
            s2 = "0" + s2;
        }
        if (s3.length() < 2) {
            s3 = "0" + s3;
        }
        if (t1.length() < 2) {
            t1 = "0" + t1;
        }
        if (t2.length() < 2) {
            t2 = "0" + t2;
        }
        if (t3.length() < 2) {
            t3 = "0" + t3;
        }

        String s = s1 + s2 + s3;
        String t = t1 + t2 + t3;
        return s.compareTo(t);
    }

    public static String getUsernameFromConnectionFactory(BeanIntrospection bi, ConnectionFactory cf) {
         
        if (cf == null) {
            return null;
        }
        Map<String, Object> props = new HashMap<>();
        bi.getProperties(cf, props, null, false);
        Object user = props.get("user");
        if (user == null) {
            user = props.get("username");
        }
        if (user == null) {
            user = props.get("userName");
        }
        if (user != null) {
            return user.toString();
        } else {
             
            ConnectionFactory ncf = (ConnectionFactory) props.get("connectionFactory");
            if (ncf != null) {
                return getUsernameFromConnectionFactory(bi, ncf);
            }
        }
        return artemisUsername(cf);
    }

    public static String extractSourceName(String loc) {
        loc = stripSourceLocationLineNumber(loc);
        if (loc != null) {
            if (loc.contains(":")) {
                 
                loc = loc.substring(loc.indexOf(':') + 1);
                 
                loc = FileUtil.stripPath(loc);
            }
        }
        return loc;
    }

    protected CancelSm createCancelSm(Exchange exchange) {
        Message in = exchange.getIn();
        CancelSm cancelSm = new CancelSm();

        if (in.getHeaders().containsKey(SmppConstants.ID)) {
            cancelSm.setMessageId(in.getHeader(SmppConstants.ID, String.class));
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR)) {
            cancelSm.setSourceAddr(in.getHeader(SmppConstants.SOURCE_ADDR, String.class));
        } else {
            cancelSm.setSourceAddr(config.getSourceAddr());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR_TON)) {
            cancelSm.setSourceAddrTon(in.getHeader(SmppConstants.SOURCE_ADDR_TON, Byte.class));
        } else {
            cancelSm.setSourceAddrTon(config.getSourceAddrTon());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR_NPI)) {
            cancelSm.setSourceAddrNpi(in.getHeader(SmppConstants.SOURCE_ADDR_NPI, Byte.class));
        } else {
            cancelSm.setSourceAddrNpi(config.getSourceAddrNpi());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR)) {
            cancelSm.setDestinationAddress(in.getHeader(SmppConstants.DEST_ADDR, String.class));
        } else {
            cancelSm.setDestinationAddress(config.getDestAddr());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR_TON)) {
            cancelSm.setDestAddrTon(in.getHeader(SmppConstants.DEST_ADDR_TON, Byte.class));
        } else {
            cancelSm.setDestAddrTon(config.getDestAddrTon());
        }

        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR_NPI)) {
            cancelSm.setDestAddrNpi(in.getHeader(SmppConstants.DEST_ADDR_NPI, Byte.class));
        } else {
            cancelSm.setDestAddrNpi(config.getDestAddrNpi());
        }

        if (in.getHeaders().containsKey(SmppConstants.SERVICE_TYPE)) {
            cancelSm.setServiceType(in.getHeader(SmppConstants.SERVICE_TYPE, String.class));
        } else {
            cancelSm.setServiceType(config.getServiceType());
        }

        return cancelSm;
    }

    protected static List<String> getParameters(String path) {
        List<String> parameters = null;

        int startIndex = path.indexOf('{');
        while (startIndex != -1) {
            int endIndex = path.indexOf('}', startIndex);
            if (endIndex != -1) {
                if (parameters == null) {
                    parameters = new ArrayList<>();
                }
                parameters.add(path.substring(startIndex + 1, endIndex));
                startIndex = path.indexOf('{', endIndex);
            } else {
                 
                startIndex = -1;
            }
        }

        return parameters == null ? Collections.emptyList() : parameters;
    }

    public void getQueryResultIds(
            String jobId, String batchId, Map<String, List<String>> headers, final QueryResultIdsCallback callback) {
        final Request get = getRequest(HttpMethod.GET, batchResultUrl(jobId, batchId, null), headers);

         
        doHttpRequest(get, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                QueryResultList value = null;
                try {
                    value = unmarshalResponse(response, get, QueryResultList.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(value != null ? Collections.unmodifiableList(value.getResult()) : null, headers, ex);
            }
        });
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        AtomicBoolean remoteVisible = new AtomicBoolean();
        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jo = (JsonObject) root.get("inflight");
                        if (jo != null) {
                            JsonArray arr = (JsonArray) jo.get("exchanges");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    jo = (JsonObject) arr.get(i);
                                    row.exchangeId = jo.getString("exchangeId");
                                    row.fromRouteId = jo.getString("fromRouteId");
                                    Boolean bool = jo.getBoolean("fromRemoteEndpoint");
                                    if (bool != null) {
                                         
                                        remoteVisible.set(true);
                                        row.fromRemoteEndpoint = bool;
                                    }
                                    row.atRouteId = jo.getString("atRouteId");
                                    row.nodeId = jo.getString("nodeId");
                                    row.elapsed = jo.getLong("elapsed");
                                    row.duration = jo.getLong("duration");
                                    rows.add(row);
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("EXCHANGE-ID").dataAlign(HorizontalAlign.LEFT).with(r -> r.exchangeId),
                    new Column().header("REMOTE").visible(remoteVisible.get()).dataAlign(HorizontalAlign.CENTER)
                            .with(this::getRemote),
                    new Column().header("ROUTE").dataAlign(HorizontalAlign.LEFT).maxWidth(25, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.atRouteId),
                    new Column().header("ID").dataAlign(HorizontalAlign.LEFT).maxWidth(25, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.nodeId),
                    new Column().header("ELAPSED").dataAlign(HorizontalAlign.RIGHT).with(this::getElapsed),
                    new Column().header("DURATION").dataAlign(HorizontalAlign.RIGHT).with(this::getDuration))));
        }

        return 0;
    }

    protected void autoConfigure(String artifactId) {
         
        InputStream is = getClass().getResourceAsStream("/auto-configure/" + artifactId + ".java");
        if (is != null) {
            try {
                 
                DependencyDownloader downloader = getCamelContext().hasService(DependencyDownloader.class);
                 
                downloader.downloadHiddenDependency("org.apache.camel", "camel-joor", camelContext.getVersion());
                 
                String script = IOHelper.loadText(is);
                Language lan = camelContext.resolveLanguage("java");
                Expression exp = lan.createExpression(script);
                Object out = exp.evaluate(new DefaultExchange(camelContext), Object.class);
                if (ObjectHelper.isNotEmpty(out)) {
                    LOG.info("{}", out);
                }
            } catch (Exception e) {
                throw RuntimeCamelException.wrapRuntimeException(e);
            } finally {
                IOHelper.close(is);
            }
        }
    }

    protected JsonObject doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();
        if (propertiesFunction != null) {
            root.put("login", "Client Id/Client Secret");
            AzureVaultConfiguration azure = getCamelContext().getVaultConfiguration().getAzureVaultConfiguration();
            if (azure != null) {
                root.put("refreshEnabled", azure.isRefreshEnabled());
                root.put("refreshPeriod", azure.getRefreshPeriod());
            }
            if (secretsRefreshTask != null) {
                Instant last = secretsRefreshTask.getLastCheckTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastCheckTimestamp", timestamp);
                    root.put("lastCheckAge", TimeUtils.printSince(timestamp));
                }
                last = secretsRefreshTask.getLastReloadTime();
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    root.put("lastReloadTimestamp", timestamp);
                    root.put("lastReloadAge", TimeUtils.printSince(timestamp));
                }
            }
            JsonArray arr = new JsonArray();
            root.put("secrets", arr);

            List<String> sorted = new ArrayList<>(propertiesFunction.getSecrets());
            Collections.sort(sorted);

            for (String sec : sorted) {
                JsonObject jo = new JsonObject();
                jo.put("name", sec);
                Instant last = secretsRefreshTask != null ? secretsRefreshTask.getUpdates().get(sec) : null;
                if (last != null) {
                    long timestamp = last.toEpochMilli();
                    jo.put("timestamp", timestamp);
                    jo.put("age", TimeUtils.printSince(timestamp));
                }
                arr.add(jo);
            }
        }
        return root;
    }

    public static KafkaResumeStrategyConfigurationBuilder newBuilder() {
        final Properties producerProperties = KafkaResumeStrategyConfigurationBuilder.createProducerProperties();
        final Properties consumerProperties = KafkaResumeStrategyConfigurationBuilder.createConsumerProperties();

        KafkaResumeStrategyConfigurationBuilder builder = new KafkaResumeStrategyConfigurationBuilder(
                producerProperties,
                consumerProperties);

        String groupId = UUID.randomUUID().toString();
        LOG.debug("Creating consumer with {}[{}]", ConsumerConfig.GROUP_ID_CONFIG, groupId);
        builder.withGroupId(groupId);
        builder.withEnableAutoCommit(true);
        builder.withCacheFillPolicy(Cacheable.FillPolicy.MAXIMIZING);

        return builder;
    }

    public void init(ManagementStrategy strategy) {
        super.init(strategy);
        this.sanitize = strategy.getManagementAgent().getMask() != null ? strategy.getManagementAgent().getMask() : true;
        if (sanitize) {
            uri = URISupport.sanitizeUri(getProcessor().getUri());
        } else {
            uri = getProcessor().getUri();
        }
    }

    private void processAbortQueryJob(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        String jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
        bulkClient.changeQueryJobState(jobId, JobStateEnum.ABORTED, determineHeaders(exchange),
                new BulkApiV2Client.QueryJobResponseCallback() {
                    @Override
                    public void onResponse(QueryJob job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    public Short getShort(final String key) {
        Object returnable = this.get(key);
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).shortValue();
    }

    private ServerCreate messageToServer(Message message) {
        ServerCreate serverCreate = message.getBody(ServerCreate.class);

        if (serverCreate == null) {
            Map headers = message.getHeaders();
            ServerCreateBuilder builder = Builders.server();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            builder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(NovaConstants.IMAGE_ID)) {
                builder.image(message.getHeader(NovaConstants.IMAGE_ID, String.class));
            }

            if (headers.containsKey(NovaConstants.NETWORK)) {
                builder.networks(message.getHeader(NovaConstants.NETWORK, List.class));
            }

            if (headers.containsKey(NovaConstants.FLAVOR_ID)) {
                builder.flavor(message.getHeader(NovaConstants.FLAVOR_ID, String.class));
            }

            if (headers.containsKey(NovaConstants.KEYPAIR_NAME)) {
                builder.keypairName(message.getHeader(NovaConstants.KEYPAIR_NAME, String.class));
            }

            if (headers.containsKey(NovaConstants.ADMIN_PASSWORD)) {
                builder.addAdminPass(message.getHeader(NovaConstants.ADMIN_PASSWORD, String.class));
            }

            serverCreate = builder.build();
        }
        return serverCreate;
    }

    public void marshal(final Exchange exchange, final Object graph, final OutputStream stream) throws Exception {
        String filename = null;

        String filepath = exchange.getIn().getHeader(FILE_NAME, String.class);
        Long fileLength = exchange.getIn().getHeader(FILE_LENGTH, Long.class);
        if (filepath != null) {
            Path filenamePath = Paths.get(filepath).getFileName();
            if (filenamePath != null) {
                filename = filenamePath.toString();  
            }
        }
        if (filename == null) {
             
            filename = filepath = StringHelper.sanitize(exchange.getIn().getMessageId());
        }
        InputStream is = exchange.getContext().getTypeConverter().mandatoryConvertTo(InputStream.class, exchange, graph);
        if (fileLength == null) {
            fileLength = (long) is.available();
        }

        ZipArchiveOutputStream zos = new ZipArchiveOutputStream(stream);
        if (preservePathElements) {
            createZipEntries(zos, filepath, fileLength);
        } else {
            createZipEntries(zos, filename, fileLength);
        }

        try {
            IOHelper.copy(is, zos);
        } finally {
            zos.closeArchiveEntry();
            IOHelper.close(is, zos);
        }

        String newFilename = filename + ".zip";
        exchange.getMessage().setHeader(FILE_NAME, newFilename);
    }

    public Consumer createConsumer(Processor processor) throws Exception {
        Consumer consumer;
        if (getConfiguration().isConsumeAsClient()) {
            consumer = new VertxWebsocketClientConsumer(this, processor);
        } else {
            consumer = new VertxWebsocketConsumer(this, processor);
        }
        configureConsumer(consumer);
        return consumer;
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        getCurrentSagaCoordinator(exchange).whenComplete((coordinator, ex) -> ifNotException(ex, exchange, callback, () -> {
            if (coordinator == null) {
                exchange.setException(new CamelExchangeException("Exchange is not part of a saga", exchange));
                callback.done(false);
            } else {
                coordinator.beginStep(exchange, step)
                        .whenComplete((done, ex2) -> ifNotException(ex2, exchange, callback, () -> {
                            super.process(exchange, doneSync -> callback.done(false));
                        }));
            }
        }));
        return false;
    }

    public static Predicate and(final Predicate left, final Predicate right) {
        notNull(left, "left");
        notNull(right, "right");
        return new Predicate() {
            public boolean matches(Exchange exchange) {
                return left.matches(exchange) && right.matches(exchange);
            }

            @Override
            public void init(CamelContext camelContext) {
                left.initPredicate(camelContext);
                right.initPredicate(camelContext);
            }

            @Override
            public String toString() {
                return "(" + left + ") and (" + right + ")";
            }
        };
    }

    private Consumer<ThroughputResponse> setThroughputResponseOnExchange(final Exchange exchange) {
        return response -> {
            if (ObjectHelper.isNotEmpty(response.getProperties())) {
                setMessageHeader(exchange, CosmosDbConstants.AUTOSCALE_MAX_THROUGHPUT,
                        response.getProperties().getAutoscaleMaxThroughput());
                setMessageHeader(exchange, CosmosDbConstants.MANUAL_THROUGHPUT, response.getProperties().getManualThroughput());
                setMessageHeader(exchange, CosmosDbConstants.E_TAG, response.getProperties().getETag());
                setMessageHeader(exchange, CosmosDbConstants.TIMESTAMP, response.getProperties().getTimestamp());
            }
            setCommonResponseOnExchange(exchange, response);
        };
    }

    public void onUpload(String host, String file, long chunkSize, long totalChunkSize, long fileSize) {
        transferredBytes = totalChunkSize;

        String msg
                = "Uploading to host: " + host + " file: " + file + " chunk (" + chunkSize + "/" + totalChunkSize + " bytes)";
        if (fileSize > 0) {
            float percent = ((float) totalChunkSize / (float) fileSize) * 100L;
            String num = String.format("%.1f", percent);
             
            if (totalChunkSize < fileSize && "100.0".equals(num)) {
                num = "99.9";
            }
            String size = StringHelper.humanReadableBytes(totalChunkSize);
            msg += " (progress: " + size + "/" + num + "%)";
        } else {
             
             
            String size = StringHelper.humanReadableBytes(totalChunkSize);
            msg += " (uploaded: " + size + ")";
        }
         
        doLogVerbose(msg);
         
        if (interval.taken() > endpoint.getTransferLoggingIntervalSeconds() * 1000) {
            doLog(msg);
            interval.restart();
        }
    }

    private void deleteFunction(CloudFunctionsServiceClient client, Exchange exchange)
            throws InvalidPayloadException, InterruptedException, ExecutionException {
        Empty response = null;
        if (getConfiguration().isPojoRequest()) {
            DeleteFunctionRequest request = exchange.getIn().getMandatoryBody(DeleteFunctionRequest.class);
            response = client.deleteFunctionAsync(request).get();
        } else {
            CloudFunctionName cfName = CloudFunctionName.of(getConfiguration().getProject(),
                    getConfiguration().getLocation(), getConfiguration().getFunctionName());
            DeleteFunctionRequest request = DeleteFunctionRequest.newBuilder().setName(cfName.toString()).build();
            response = client.deleteFunctionAsync(request).get();
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(response);
    }

    public void onPutIfAbsent(Message message) {
        final BasicCache<Object, Object> cache = getCache(message);
        final Object key = message.getHeader(InfinispanConstants.KEY, configuration::getKey);
        final Object value = message.getHeader(InfinispanConstants.VALUE, configuration::getValue);
        final Object result;

        if (hasLifespan(message)) {
            long lifespan = message.getHeader(InfinispanConstants.LIFESPAN_TIME, long.class);
            TimeUnit timeUnit = message.getHeader(InfinispanConstants.LIFESPAN_TIME_UNIT, TimeUnit.class);

            if (hasMaxIdleTime(message)) {
                long maxIdle = message.getHeader(InfinispanConstants.MAX_IDLE_TIME, long.class);
                TimeUnit maxIdleTimeUnit = message.getHeader(InfinispanConstants.MAX_IDLE_TIME_UNIT, TimeUnit.class);

                result = cache.putIfAbsent(key, value, lifespan, timeUnit, maxIdle, maxIdleTimeUnit);
            } else {
                result = cache.putIfAbsent(key, value, lifespan, timeUnit);
            }
        } else {
            result = cache.putIfAbsent(key, value);
        }

        setResult(message, result);
    }

    public InputStream resource(String path, Object resource, Map<String, Object> queryParams) {
        PostOperation postOperation = dhis2Client.post(path);
        if (queryParams != null) {
            for (Map.Entry<String, Object> queryParam : queryParams.entrySet()) {
                if (queryParam.getValue() instanceof List) {
                    for (String queryValue : (List<String>) queryParam.getValue()) {
                        postOperation.withParameter(queryParam.getKey(), queryValue);
                    }
                } else {
                    postOperation.withParameter(queryParam.getKey(), (String) queryParam.getValue());
                }
            }
        }

        if (resource != null) {
            postOperation.withResource(resource);
        }

        return postOperation.transfer().read();

    }

    private Router messageToRouter(Message message) {
        Router router = message.getBody(Router.class);

        if (router == null) {
            Map headers = message.getHeaders();
            RouterBuilder builder = Builders.router();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            builder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(NeutronConstants.TENANT_ID)) {
                builder.tenantId(message.getHeader(NeutronConstants.TENANT_ID, String.class));
            }

            router = builder.build();
        }
        return router;
    }

    List<Row> collectRows() {
        List<Row> rows = new ArrayList<>();
        for (String name : catalog.findLanguageNames()) {
            LanguageModel model = catalog.languageModel(name);
            if (model != null) {
                Row row = new Row();
                row.name = model.getName();
                row.title = model.getTitle();
                row.level = model.getSupportLevel().name();
                row.since = fixQuarkusSince(model.getFirstVersionShort());
                row.description = model.getDescription();
                row.label = model.getLabel() != null ? model.getLabel() : "";
                row.deprecated = model.isDeprecated();
                row.nativeSupported = model.isNativeSupported();
                row.gav = getGAV(model);
                rows.add(row);
            }
        }
        return rows;
    }

    public Map<String, String> getServiceMetadata() {
        Map<String, String> map = new HashMap<>();
        if (configuration.getClientId() != null) {
            map.put("clientId", configuration.getClientId());
        }
        if (configuration.getUserName() != null) {
            map.put("username", configuration.getUserName());
        }
        return map.isEmpty() ? null : map;
    }

    public void onPut(Message message) {
        final BasicCache<Object, Object> cache = getCache(message);
        final Object key = message.getHeader(InfinispanConstants.KEY, configuration::getKey);
        final Object value = message.getHeader(InfinispanConstants.VALUE, configuration::getValue);
        final Object result;

        if (hasLifespan(message)) {
            long lifespan = message.getHeader(InfinispanConstants.LIFESPAN_TIME, long.class);
            TimeUnit timeUnit = message.getHeader(InfinispanConstants.LIFESPAN_TIME_UNIT, TimeUnit.class);

            if (hasMaxIdleTime(message)) {
                long maxIdle = message.getHeader(InfinispanConstants.MAX_IDLE_TIME, long.class);
                TimeUnit maxIdleTimeUnit = message.getHeader(InfinispanConstants.MAX_IDLE_TIME_UNIT, TimeUnit.class);

                result = cache.put(key, value, lifespan, timeUnit, maxIdle, maxIdleTimeUnit);
            } else {
                result = cache.put(key, value, lifespan, timeUnit);
            }
        } else {
            result = cache.put(key, value);
        }

        setResult(message, result);
    }

    public JobResponse failJob(JobRequest message) {
        JobResponse resultMessage = new JobResponse();

        try {
            GatewayGrpc.GatewayBlockingStub stub = GatewayGrpc.newBlockingStub(managedChannel);
            GatewayOuterClass.FailJobRequest.Builder builder = GatewayOuterClass.FailJobRequest.newBuilder()
                    .setJobKey(message.getJobKey());
            builder = builder.setRetries(message.getRetries());
            builder = builder.setErrorMessage(message.getFailMessage());
            GatewayOuterClass.FailJobRequest request = builder.build();
            GatewayOuterClass.FailJobResponse failJobResponse = stub.failJob(request);

            resultMessage.setSuccess(true);
        } catch (StatusRuntimeException exception) {
            LOG.error(String.format("Cannot fail Job %s", message.getJobKey()), exception);
            resultMessage.setErrorMessage(exception.getMessage());
            resultMessage.setErrorCode(exception.getStatus().toString());
            resultMessage.setSuccess(false);
        }

        return resultMessage;
    }

    public static String extractState(int status) {
        if (status <= 4) {
            return "Starting";
        } else if (status == 5) {
            return "Running";
        } else if (status == 6) {
            return "Suspending";
        } else if (status == 7) {
            return "Suspended";
        } else if (status == 8) {
            return "Terminating";
        } else if (status == 9) {
            return "Terminated";
        } else {
            return "Terminated";
        }
    }

    public Producer createProducer() throws Exception {
        switch (getSubsystem()) {
            case KeystoneConstants.REGIONS:
                return new RegionProducer(this, createClient());
            case KeystoneConstants.DOMAINS:
                return new DomainProducer(this, createClient());
            case KeystoneConstants.PROJECTS:
                return new ProjectProducer(this, createClient());
            case KeystoneConstants.USERS:
                return new UserProducer(this, createClient());
            case KeystoneConstants.GROUPS:
                return new GroupProducer(this, createClient());
            default:
                throw new IllegalArgumentException("Can't create producer with subsystem " + subsystem);
        }
    }

    private void listModels(Exchange exchange) {
        SpeechToText stt = getEndpoint().getSttClient();
        if (stt == null) {
            throw new IllegalStateException("STT client not initialized");
        }

        LOG.trace("Listing available speech recognition models");

        SpeechModels models = stt.listModels().execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(models.getModels());
    }

    protected Validator doCreateValidator() {
        if (definition.getRef() == null && definition.getClassName() == null) {
            throw new IllegalArgumentException("'ref' or 'type' must be specified for customValidator");
        }
        Validator validator;
        if (definition.getRef() != null) {
            validator = lookupByNameAndType(definition.getRef(), Validator.class);
            if (validator == null) {
                throw new IllegalArgumentException("Cannot find validator with ref:" + definition.getRef());
            }
            if (validator.getType() != null) {
                throw new IllegalArgumentException(
                        String.format("Validator '%s' is already in use. Please check if duplicate validator exists.",
                                definition.getRef()));
            }
        } else {
            Class<Validator> validatorClass
                    = camelContext.getClassResolver().resolveClass(definition.getClassName(), Validator.class);
            if (validatorClass == null) {
                throw new IllegalArgumentException("Cannot find validator class: " + definition.getClassName());
            }
             
            validator = camelContext.getInjector().newInstance(validatorClass, false);  
        }
        validator.setCamelContext(camelContext);
        return validator.setType(definition.getType());
    }

    private static int zzUnpackAction(String packed, int offset, int[] result) {
        int i = 0;  
        int j = offset;  
        int l = packed.length();
        while (i < l) {
            int count = packed.charAt(i++);
            int value = packed.charAt(i++);
            do {
                result[j++] = value;
            } while (--count > 0);
        }
        return j;
    }

    private void closeListeners(Exchange exchange, String message) {
        if (listeners == null || listeners.isEmpty()) {
            return;
        }
        for (LogListener listener : listeners) {
            if (listener == null) {
                continue;
            }
            try {
                listener.afterLog(exchange, logger, message);
            } catch (Exception t) {
                LOG.warn("Ignoring an exception thrown by {}: {}", listener.getClass().getName(), t.getMessage());
                if (LOG.isDebugEnabled()) {
                    LOG.debug("", t);
                }
            }
        }
    }

        public void onReply(int num, String value, String msg) {
            if (configuration.isOnReply()) {
                Exchange exchange = createOnReplyExchange(num, value, msg);
                try {
                    getProcessor().process(exchange);
                } catch (Exception e) {
                    handleException(e);
                }
            }
        }

    protected void autoConfigure(String key) {
        var config = new org.apache.camel.util.OrderedLocationProperties();
        config.putAll("camel-main", camelContext.getPropertiesComponent().loadProperties());

         
        InputStream is = getClass().getResourceAsStream("/auto-configure/" + key + ".java");
        if (is != null) {
            try {
                 
                DependencyDownloader downloader = camelContext.hasService(DependencyDownloader.class);
                 
                downloader.downloadHiddenDependency("org.apache.camel", "camel-joor", camelContext.getVersion());
                 
                String script = IOHelper.loadText(is);
                Language lan = camelContext.resolveLanguage("java");
                Expression exp = lan.createExpression(script);
                Object out = exp.evaluate(new DefaultExchange(camelContext), Object.class);
                if (ObjectHelper.isNotEmpty(out)) {
                    LOG.info("{}", out);
                }
            } catch (Exception e) {
                throw RuntimeCamelException.wrapRuntimeException(e);
            } finally {
                IOHelper.close(is);
            }
        }
    }

    public static Predicate isEqualToIgnoreCase(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return true;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceEquals(exchange.getContext().getTypeConverter(), leftValue, rightValue, true);
            }

            protected String getOperationText() {
                return "=~";
            }
        };
    }

    protected void unInitReplyManager() {
        try {
            if (replyManager != null) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Stopping RocketMQReplyManager: {} from processing replies from : {}", replyManager,
                            getEndpoint().getReplyToTopic());
                }
                ServiceHelper.stopService(replyManager);
            }
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        } finally {
            started.set(false);
        }
    }

    public static Point fromMapToPoint(Map<String, Object> map) {
        Object measurementName = map.get(InfluxDbConstants.MEASUREMENT_NAME);
        if (measurementName == null) {
            String format = String.format("Unable to find the header for the measurement in: %s", map.keySet().toString());
            throw new CamelInfluxDbException(format);
        }

        String measurenmentNameString = measurementName.toString();
        Point.Builder pointBuilder = Point.measurement(measurenmentNameString);
        map.remove(InfluxDbConstants.MEASUREMENT_NAME);
        pointBuilder.fields(map);
        map.put(InfluxDbConstants.MEASUREMENT_NAME, measurementName);
        return pointBuilder.build();
    }

        protected boolean setProperty(DataFormatTransformerDefinition target, String propertyKey,
                String propertyName, Node node) {
            propertyKey = org.apache.camel.util.StringHelper.dashToCamelCase(propertyKey);
            switch(propertyKey) {
                case "dataFormatType": {
                    MappingNode val = asMappingNode(node);
                    setProperties(target, val);
                    break;
                }
                case "asn1": {
                    org.apache.camel.model.dataformat.ASN1DataFormat val = asType(node, org.apache.camel.model.dataformat.ASN1DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "avro": {
                    org.apache.camel.model.dataformat.AvroDataFormat val = asType(node, org.apache.camel.model.dataformat.AvroDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "barcode": {
                    org.apache.camel.model.dataformat.BarcodeDataFormat val = asType(node, org.apache.camel.model.dataformat.BarcodeDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "base64": {
                    org.apache.camel.model.dataformat.Base64DataFormat val = asType(node, org.apache.camel.model.dataformat.Base64DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "beanio": {
                    org.apache.camel.model.dataformat.BeanioDataFormat val = asType(node, org.apache.camel.model.dataformat.BeanioDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "bindy": {
                    org.apache.camel.model.dataformat.BindyDataFormat val = asType(node, org.apache.camel.model.dataformat.BindyDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "cbor": {
                    org.apache.camel.model.dataformat.CBORDataFormat val = asType(node, org.apache.camel.model.dataformat.CBORDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "crypto": {
                    org.apache.camel.model.dataformat.CryptoDataFormat val = asType(node, org.apache.camel.model.dataformat.CryptoDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "csv": {
                    org.apache.camel.model.dataformat.CsvDataFormat val = asType(node, org.apache.camel.model.dataformat.CsvDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "custom": {
                    org.apache.camel.model.dataformat.CustomDataFormat val = asType(node, org.apache.camel.model.dataformat.CustomDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "dfdl": {
                    org.apache.camel.model.dataformat.DfdlDataFormat val = asType(node, org.apache.camel.model.dataformat.DfdlDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "fhirJson": {
                    org.apache.camel.model.dataformat.FhirJsonDataFormat val = asType(node, org.apache.camel.model.dataformat.FhirJsonDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "fhirXml": {
                    org.apache.camel.model.dataformat.FhirXmlDataFormat val = asType(node, org.apache.camel.model.dataformat.FhirXmlDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "flatpack": {
                    org.apache.camel.model.dataformat.FlatpackDataFormat val = asType(node, org.apache.camel.model.dataformat.FlatpackDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "fory": {
                    org.apache.camel.model.dataformat.ForyDataFormat val = asType(node, org.apache.camel.model.dataformat.ForyDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "grok": {
                    org.apache.camel.model.dataformat.GrokDataFormat val = asType(node, org.apache.camel.model.dataformat.GrokDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "groovyXml": {
                    org.apache.camel.model.dataformat.GroovyXmlDataFormat val = asType(node, org.apache.camel.model.dataformat.GroovyXmlDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "gzipDeflater": {
                    org.apache.camel.model.dataformat.GzipDeflaterDataFormat val = asType(node, org.apache.camel.model.dataformat.GzipDeflaterDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "hl7": {
                    org.apache.camel.model.dataformat.HL7DataFormat val = asType(node, org.apache.camel.model.dataformat.HL7DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "ical": {
                    org.apache.camel.model.dataformat.IcalDataFormat val = asType(node, org.apache.camel.model.dataformat.IcalDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "iso8583": {
                    org.apache.camel.model.dataformat.Iso8583DataFormat val = asType(node, org.apache.camel.model.dataformat.Iso8583DataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "jacksonXml": {
                    org.apache.camel.model.dataformat.JacksonXMLDataFormat val = asType(node, org.apache.camel.model.dataformat.JacksonXMLDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "jaxb": {
                    org.apache.camel.model.dataformat.JaxbDataFormat val = asType(node, org.apache.camel.model.dataformat.JaxbDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "json": {
                    org.apache.camel.model.dataformat.JsonDataFormat val = asType(node, org.apache.camel.model.dataformat.JsonDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "jsonApi": {
                    org.apache.camel.model.dataformat.JsonApiDataFormat val = asType(node, org.apache.camel.model.dataformat.JsonApiDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "lzf": {
                    org.apache.camel.model.dataformat.LZFDataFormat val = asType(node, org.apache.camel.model.dataformat.LZFDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "mimeMultipart": {
                    org.apache.camel.model.dataformat.MimeMultipartDataFormat val = asType(node, org.apache.camel.model.dataformat.MimeMultipartDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "parquetAvro": {
                    org.apache.camel.model.dataformat.ParquetAvroDataFormat val = asType(node, org.apache.camel.model.dataformat.ParquetAvroDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "protobuf": {
                    org.apache.camel.model.dataformat.ProtobufDataFormat val = asType(node, org.apache.camel.model.dataformat.ProtobufDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "rss": {
                    org.apache.camel.model.dataformat.RssDataFormat val = asType(node, org.apache.camel.model.dataformat.RssDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "smooks": {
                    org.apache.camel.model.dataformat.SmooksDataFormat val = asType(node, org.apache.camel.model.dataformat.SmooksDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "soap": {
                    org.apache.camel.model.dataformat.SoapDataFormat val = asType(node, org.apache.camel.model.dataformat.SoapDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "swiftMt": {
                    org.apache.camel.model.dataformat.SwiftMtDataFormat val = asType(node, org.apache.camel.model.dataformat.SwiftMtDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "swiftMx": {
                    org.apache.camel.model.dataformat.SwiftMxDataFormat val = asType(node, org.apache.camel.model.dataformat.SwiftMxDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "syslog": {
                    org.apache.camel.model.dataformat.SyslogDataFormat val = asType(node, org.apache.camel.model.dataformat.SyslogDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "tarFile": {
                    org.apache.camel.model.dataformat.TarFileDataFormat val = asType(node, org.apache.camel.model.dataformat.TarFileDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "thrift": {
                    org.apache.camel.model.dataformat.ThriftDataFormat val = asType(node, org.apache.camel.model.dataformat.ThriftDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "univocityCsv": {
                    org.apache.camel.model.dataformat.UniVocityCsvDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityCsvDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "univocityFixed": {
                    org.apache.camel.model.dataformat.UniVocityFixedDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityFixedDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "univocityTsv": {
                    org.apache.camel.model.dataformat.UniVocityTsvDataFormat val = asType(node, org.apache.camel.model.dataformat.UniVocityTsvDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "xmlSecurity": {
                    org.apache.camel.model.dataformat.XMLSecurityDataFormat val = asType(node, org.apache.camel.model.dataformat.XMLSecurityDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "pgp": {
                    org.apache.camel.model.dataformat.PGPDataFormat val = asType(node, org.apache.camel.model.dataformat.PGPDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "yaml": {
                    org.apache.camel.model.dataformat.YAMLDataFormat val = asType(node, org.apache.camel.model.dataformat.YAMLDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "zipDeflater": {
                    org.apache.camel.model.dataformat.ZipDeflaterDataFormat val = asType(node, org.apache.camel.model.dataformat.ZipDeflaterDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "zipFile": {
                    org.apache.camel.model.dataformat.ZipFileDataFormat val = asType(node, org.apache.camel.model.dataformat.ZipFileDataFormat.class);
                    target.setDataFormatType(val);
                    break;
                }
                case "fromType": {
                    String val = asText(node);
                    target.setFromType(val);
                    break;
                }
                case "name": {
                    String val = asText(node);
                    target.setName(val);
                    break;
                }
                case "scheme": {
                    String val = asText(node);
                    target.setScheme(val);
                    break;
                }
                case "toType": {
                    String val = asText(node);
                    target.setToType(val);
                    break;
                }
                default: {
                    return false;
                }
            }
            return true;
        }

    public DataLakeOperationResponse listPaths(final Exchange exchange) {
        final ListPathsOptions listPathsOptions = configurationProxy.getListPathOptions(exchange);
        final Duration timeout = configurationProxy.getTimeout(exchange);
        final String regex = configurationProxy.getRegex(exchange);
        List<PathItem> paths = client.listPaths(listPathsOptions, timeout);

        if (ObjectHelper.isEmpty(regex)) {
            return new DataLakeOperationResponse(paths);
        } else {
            List<PathItem> filteredPaths = paths.stream()
                    .filter(x -> x.getName().matches(regex))
                    .collect(Collectors.toCollection(LinkedList<PathItem>::new));
            return new DataLakeOperationResponse(filteredPaths);
        }
    }

    SSLContext provideSSLContext() throws GeneralSecurityException, IOException {
        if (sslContextParameters != null) {
            return sslContextParameters.createSSLContext(getCamelContext());
        } else if (getComponent().getSslContextParameters() != null) {
            return getComponent().getSslContextParameters().createSSLContext(getCamelContext());
        } else {
            return null;
        }
    }

    private void doCreateOrUpdateSecret(Exchange exchange, String operationName, Function<Resource<Secret>, Secret> operation) {
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Secret secretToCreate = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SECRET, Secret.class);
        HashMap<String, String> secretAnnotations
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_SECRETS_ANNOTATIONS, HashMap.class);
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific secret require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific secret require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(secretToCreate)) {
            LOG.error("{} a specific secret require specify a secret bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific secret require specify a secret bean", operationName));
        }
        if (ObjectHelper.isNotEmpty(secretAnnotations)) {
            secretToCreate.getMetadata().setAnnotations(secretAnnotations);
        }
        Secret secret
                = operation.apply(
                        getEndpoint().getKubernetesClient().secrets().inNamespace(namespaceName).resource(secretToCreate));

        prepareOutboundMessage(exchange, secret);
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jo = (JsonObject) root.get("services");
                        if (jo != null) {
                            JsonArray arr = (JsonArray) jo.get("services");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    jo = (JsonObject) arr.get(i);
                                    row.component = jo.getString("component");
                                    row.direction = jo.getString("direction");
                                    row.hosted = jo.getBooleanOrDefault("hosted", false);
                                    row.protocol = jo.getString("protocol");
                                    row.serviceUrl = jo.getString("serviceUrl");
                                    row.endpointUri = jo.getString("endpointUri");
                                    row.hits = jo.getLongOrDefault("hits", 0);
                                    row.routeId = jo.getString("routeId");
                                    row.metadata = jo.getMap("metadata");
                                    rows.add(row);
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("COMPONENT").dataAlign(HorizontalAlign.LEFT).with(r -> r.component),
                    new Column().header("DIR").dataAlign(HorizontalAlign.LEFT).with(r -> r.direction),
                    new Column().header("ROUTE").dataAlign(HorizontalAlign.LEFT).with(this::getRouteId),
                    new Column().header("PROTOCOL").dataAlign(HorizontalAlign.LEFT).with(this::getProtocol),
                    new Column().header("SERVICE").dataAlign(HorizontalAlign.LEFT).with(this::getService),
                    new Column().header("METADATA").visible(metadata).dataAlign(HorizontalAlign.LEFT).with(this::getMetadata),
                    new Column().header("TOTAL").dataAlign(HorizontalAlign.RIGHT).with(r -> "" + r.hits),
                    new Column().header("ENDPOINT").visible(!wideUri).dataAlign(HorizontalAlign.LEFT)
                            .maxWidth(90, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(this::getUri),
                    new Column().header("ENDPOINT").visible(wideUri).dataAlign(HorizontalAlign.LEFT)
                            .maxWidth(140, OverflowBehaviour.NEWLINE)
                            .with(this::getUri))));
        }

        return 0;
    }

    private void loadProperties(Map<String, Object> properties, Optional<?> optional, PropertyConfigurer configurer) {
        BeanIntrospection beanIntrospection = PluginHelper.getBeanIntrospection(camelContext);
        optional.ifPresent(bean -> {
            if (configurer instanceof ExtendedPropertyConfigurerGetter) {
                ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
                Map<String, Object> types = getter.getAllOptions(bean);
                types.forEach((k, t) -> {
                    Object value = getter.getOptionValue(bean, k, true);
                    if (value != null) {
                        properties.put(k, value);
                    }
                });
            } else {
                 
                beanIntrospection.getProperties(bean, properties, null, false);
            }
        });
    }

    public Map<String, Object> toMap() {
        JsonObject jo = new JsonObject();
        jo.put("camelVersion", version);
        jo.put("runtime", runtime);
        if (runtimeVersion != null) {
            jo.put("runtimeVersion", runtimeVersion);
        }
        if (description != null) {
            jo.put("description", description);
        }
        return jo;
    }

    public OutputLengthGuardrail(int maxChars, int minChars, boolean truncateOnOverflow) {
        if (maxChars <= 0) {
            throw new IllegalArgumentException("maxChars must be positive");
        }
        if (minChars < 0) {
            throw new IllegalArgumentException("minChars cannot be negative");
        }
        if (minChars > maxChars) {
            throw new IllegalArgumentException("minChars cannot exceed maxChars");
        }
        this.maxChars = maxChars;
        this.minChars = minChars;
        this.truncateOnOverflow = truncateOnOverflow;
    }

    protected void sendReply(
            Session session,
            Destination replyDestination, final Message message, final Exchange exchange,
            final org.apache.camel.Message out, final Exception cause) {
        if (replyDestination == null) {
            LOG.debug("Cannot send reply message as there is no replyDestination for: {}", out);
            return;
        }
        try {
            SessionCallback callback = createSessionCallback(replyDestination, message, exchange, out, cause,
                    endpoint.getJmsObjectFactory()::createMessageProducer);

            getTemplate().execute(session, callback);

        } catch (Exception e) {
            exchange.setException(new CamelExchangeException("Unable to send reply JMS message", exchange, e));
        }
    }

    public static EventHubProducerAsyncClient createEventHubProducerAsyncClient(final EventHubsConfiguration configuration) {
        EventHubClientBuilder eventHubClientBuilder = new EventHubClientBuilder()
                .transportType(configuration.getAmqpTransportType())
                .retryOptions(configuration.getAmqpRetryOptions());

        CredentialType type = configuration.getCredentialType();
        if (type == null) {
            type = CredentialType.CONNECTION_STRING;
        }
        if (CredentialType.CONNECTION_STRING.equals(type)) {
            return eventHubClientBuilder
                    .connectionString(buildConnectionString(configuration))
                    .buildAsyncProducerClient();
        } else if (CredentialType.TOKEN_CREDENTIAL.equals(type)) {

            checkTokenCredentialConfiguration(configuration);
            return eventHubClientBuilder
                    .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                    .eventHubName(configuration.getEventHubName())
                    .credential(configuration.getTokenCredential())
                    .buildAsyncProducerClient();
        }
        return eventHubClientBuilder
                .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                .eventHubName(configuration.getEventHubName())
                .credential(new DefaultAzureCredentialBuilder().build())
                .buildAsyncProducerClient();
    }

    public Processor createProcessor() throws Exception {
        if (definition.getVariables().isEmpty()) {
            throw new IllegalArgumentException("There must be at least one variable specified");
        }
        List<Expression> nameExprs = new java.util.ArrayList<>(definition.getVariables().size());
        List<Expression> valueExprs = new java.util.ArrayList<>(definition.getVariables().size());
        for (SetVariableDefinition varDef : definition.getVariables()) {
            valueExprs.add(createExpression(varDef.getExpression()));
            Expression nameExpr;
            String key = parseString(varDef.getName());
            if (LanguageSupport.hasSimpleFunction(key)) {
                nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
            } else {
                nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
            }
            nameExpr.init(camelContext);
            nameExprs.add(nameExpr);
        }

        SetVariablesProcessor answer = new SetVariablesProcessor(nameExprs, valueExprs);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, java.io.InputStream.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToInputStream((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.io.Reader.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToReader((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.io.Serializable.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToSerializable((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, org.apache.camel.component.file.GenericFile.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.file.GenericFileConverter.genericFileToString((org.apache.camel.component.file.GenericFile) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        IgniteCompute compute = endpoint.createIgniteCompute().withAsync();

        try {
            switch (executionTypeFor(exchange)) {

                case CALL:
                    doCall(exchange, compute);
                    break;

                case BROADCAST:
                    doBroadcast(exchange, compute);
                    break;

                case EXECUTE:
                    doExecute(exchange, compute);
                    break;

                case RUN:
                    doRun(exchange, compute);
                    break;

                case APPLY:
                    doApply(exchange, compute);
                    break;

                case AFFINITY_CALL:
                    doAffinityCall(exchange, compute);
                    break;

                case AFFINITY_RUN:
                    doAffinityRun(exchange, compute);
                    break;

                default:
                    exchange.setException(
                            new UnsupportedOperationException("Operation not supported by Ignite Compute producer."));
                    callback.done(false);
                    return false;
            }

            compute.future().listen(IgniteInCamelClosure.create(exchange, callback));
            return false;

        } catch (Exception e) {
            exchange.setException(e);
            callback.done(false);
            return false;
        }
    }

    public void setCommitmentTypeQualifiers(List<String> commitmentTypeQualifiers) {
        if (commitmentTypeQualifiers == null) {
            throw new IllegalArgumentException("Parameter 'commitmentTypeQualifiers' is null");
        }
        for (String qualifier : commitmentTypeQualifiers) {
            if (qualifier == null || qualifier.isEmpty()) {
                throw new IllegalArgumentException("At least one qualifier of the commitment type is null or empty");
            }
        }
        this.commitmentTypeQualifiers = new ArrayList<>(commitmentTypeQualifiers);
    }

    private Region messageToRegion(Message message) {
        Region region = message.getBody(Region.class);
        if (region == null) {
            Map headers = message.getHeaders();
            RegionBuilder builder = Builders.region();

            if (headers.containsKey(KeystoneConstants.DESCRIPTION)) {
                builder.description(message.getHeader(KeystoneConstants.DESCRIPTION, String.class));
            }

            region = builder.build();
        }

        return region;
    }

        public void run() {
            FilterWatchListDeletable<ReplicationController, ReplicationControllerList, RollableScalableResource<ReplicationController>> w;

             
            String namespace = getEndpoint().getKubernetesConfiguration().getNamespace();
            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isEmpty(namespace)) {
                w = getEndpoint().getKubernetesClient().replicationControllers().inAnyNamespace();

                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = w.withLabel(labelKey, labelValue);
                }
            } else {
                final NonNamespaceOperation<ReplicationController, ReplicationControllerList, RollableScalableResource<ReplicationController>> client
                        = getEndpoint().getKubernetesClient().replicationControllers().inNamespace(namespace);
                w = client;
                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = client.withLabel(labelKey, labelValue);
                } else if (ObjectHelper.isNotEmpty(resourceName)) {
                    w = (FilterWatchListDeletable<ReplicationController, ReplicationControllerList, RollableScalableResource<ReplicationController>>) client
                            .withName(resourceName);
                }
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, ReplicationController resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }
                }

            });
        }

    private void processConverseStreamingRequest(ConverseStreamRequest request, Exchange exchange) {
        try {
            String streamOutputMode = getConfiguration().getStreamOutputMode();
            if (streamOutputMode == null) {
                streamOutputMode = "complete";
            }

             
            if (ObjectHelper.isNotEmpty(exchange.getMessage().getHeader(BedrockConstants.STREAM_OUTPUT_MODE))) {
                streamOutputMode = exchange.getIn().getHeader(BedrockConstants.STREAM_OUTPUT_MODE, String.class);
            }

            org.apache.camel.Message message = getMessageForResponse(exchange);
            org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.StreamMetadata metadata
                    = new org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.StreamMetadata();

            if ("chunks".equals(streamOutputMode)) {
                 
                List<String> allChunks = new ArrayList<>();
                getEndpoint().getBedrockRuntimeAsyncClient().converseStream(
                        request,
                        org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.createChunksHandler(
                                metadata,
                                allChunks,
                                null))
                        .join();

                message.setBody(allChunks);
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setConverseStreamingMetadata(message, metadata);
                }
            } else {
                 
                StringBuilder fullText = new StringBuilder();
                getEndpoint().getBedrockRuntimeAsyncClient().converseStream(
                        request,
                        org.apache.camel.component.aws2.bedrock.runtime.stream.ConverseStreamHandler.createCompleteHandler(
                                metadata,
                                fullText))
                        .join();

                message.setBody(fullText.toString());
                if (getConfiguration().isIncludeStreamingMetadata()) {
                    setConverseStreamingMetadata(message, metadata);
                }
            }

        } catch (AwsServiceException ase) {
            LOG.trace("Converse Stream command returned the error code {}", ase.awsErrorDetails().errorCode());
            throw ase;
        }
    }

    private void initializeSdkClient(FaceRecognitionEndpoint endpoint, ClientConfigurations clientConfigurations) {
        if (endpoint.getFrsClient() != null) {
            LOG.info(
                    "Instance of FrsClient was set on the endpoint. Skip creation of FrsClient from endpoint parameters");
            this.frsClient = endpoint.getFrsClient();
            return;
        }
        HttpConfig httpConfig
                = HttpConfig.getDefaultHttpConfig().withIgnoreSSLVerification(clientConfigurations.isIgnoreSslVerification());
        if (!StringUtils.isEmpty(clientConfigurations.getProxyHost())) {
            httpConfig.setProxyHost(clientConfigurations.getProxyHost());
            httpConfig.setProxyPort(clientConfigurations.getProxyPort());
            if (!StringUtils.isEmpty(clientConfigurations.getProxyUser())) {
                httpConfig.setProxyUsername(clientConfigurations.getProxyUser());
                httpConfig.setProxyPassword(clientConfigurations.getProxyPassword());
            }
        }
        BasicCredentials credentials = new BasicCredentials().withAk(clientConfigurations.getAccessKey())
                .withSk(clientConfigurations.getSecretKey())
                .withProjectId(clientConfigurations.getProjectId());

        frsClient = FrsClient.newBuilder()
                .withCredential(credentials)
                .withHttpConfig(httpConfig)
                .withEndpoint(clientConfigurations.getEndpoint())
                .build();

        if (LOG.isDebugEnabled()) {
            LOG.debug("Successfully initialized FRS client");
        }
    }

    public static ApplicationEntity parseEDIEntityBody(
            AS2SessionInputBuffer inbuffer,
            InputStream is,
            String boundary,
            ContentType ediMessageContentType,
            String contentTransferEncoding,
            String filename)
            throws ParseException {
        CharsetDecoder previousDecoder = inbuffer.getCharsetDecoder();

        try {
            Charset charset = ediMessageContentType.getCharset();
            if (charset == null) {
                charset = StandardCharsets.US_ASCII;
            }
            CharsetDecoder charsetDecoder = charset.newDecoder();

            inbuffer.setCharsetDecoder(charsetDecoder);

            byte[] ediMessageBodyPartContentBytes
                    = parseBodyPartBytes(inbuffer, is, boundary, ediMessageContentType, contentTransferEncoding);

            return EntityUtils.createEDIEntity(ediMessageBodyPartContentBytes,
                    ediMessageContentType, contentTransferEncoding, false, filename);
        } catch (Exception e) {
            ParseException parseException = new ParseException("failed to parse EDI entity");
            parseException.initCause(e);
            throw parseException;
        } finally {
            inbuffer.setCharsetDecoder(previousDecoder);
        }
    }

    private SftpRemoteFile[] pollNamedFile() {
        SftpRemoteFile[] files = null;

         
         
        Exchange dummy = ExchangeHelper.getDummy(getEndpoint().getCamelContext());
        String name = evaluateFileExpression(dummy);
        if (name != null) {
            SftpRemoteFile file = new SftpRemoteFileSingle(name);
            files = new SftpRemoteFile[1];
            files[0] = file;
        }

        return files;
    }

    public RemoteFileOperations<FTPFile> createRemoteFileOperations() throws Exception {
         
        FTPClient client = ftpClient;

        if (client == null) {
             
             
            client = createFtpClient();
        }

         
         
        if (getBufferSize() > 0) {
            client.setBufferSize(getBufferSize());
        }
         
        if (getConfiguration().getConnectTimeout() > -1) {
            client.setConnectTimeout(getConfiguration().getConnectTimeout());
        }
        if (getConfiguration().getSoTimeout() > -1) {
            soTimeout = getConfiguration().getSoTimeout();
        }
        dataTimeout = getConfiguration().getTimeout();

        if (getConfiguration().getActivePortRange() != null) {
             
            String[] parts = getConfiguration().getActivePortRange().split("-");
            if (parts.length != 2) {
                throw new IllegalArgumentException("The option activePortRange should have syntax: min-max");
            }
            int min = getCamelContext().getTypeConverter().mandatoryConvertTo(int.class, parts[0]);
            int max = getCamelContext().getTypeConverter().mandatoryConvertTo(int.class, parts[1]);
            LOG.debug("Using active port range: {}-{}", min, max);
            client.setActivePortRange(min, max);
        }

         
        if (ftpClientParameters != null) {
            Map<String, Object> localParameters = new HashMap<>(ftpClientParameters);
             
             
            Object timeout = localParameters.remove("soTimeout");
            if (timeout != null) {
                soTimeout = getCamelContext().getTypeConverter().convertTo(int.class, timeout);
            }
             
            timeout = localParameters.remove("dataTimeout");
            if (timeout != null) {
                dataTimeout = getCamelContext().getTypeConverter().convertTo(int.class, timeout);
            }
            setProperties(client, localParameters);
        }

        if (ftpClientConfigParameters != null) {
             
             
            if (ftpClientConfig == null) {
                ftpClientConfig = new FTPClientConfig();
            }
            Map<String, Object> localConfigParameters = new HashMap<>(ftpClientConfigParameters);
            setProperties(ftpClientConfig, localConfigParameters);
        }

        if (dataTimeout > 0) {
            client.setDataTimeout(dataTimeout);
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Created FTPClient[connectTimeout: {}, soTimeout: {}, dataTimeout: {}, bufferSize: {}"
                      + ", receiveDataSocketBufferSize: {}, sendDataSocketBufferSize: {}]: {}",
                    client.getConnectTimeout(), getSoTimeout(), dataTimeout, client.getBufferSize(),
                    client.getReceiveDataSocketBufferSize(), client.getSendDataSocketBufferSize(), client);
        }

        FtpOperations operations = new FtpOperations(client, getFtpClientConfig());
        operations.setEndpoint(this);
        return operations;
    }

    protected void doStart() throws Exception {
        super.doStart();
        String token = System.getenv(CAMEL_HASHICORP_VAULT_TOKEN_ENV);
        String host = System.getenv(CAMEL_HASHICORP_VAULT_HOST_ENV);
        String port = System.getenv(CAMEL_HASHICORP_VAULT_PORT_ENV);
        String scheme = System.getenv(CAMEL_HASHICORP_VAULT_SCHEME_ENV);
        if (System.getenv(CAMEL_HASHICORP_VAULT_CLOUD_ENV) != null) {
            cloud = Boolean.parseBoolean(System.getenv(CAMEL_HASHICORP_VAULT_CLOUD_ENV));
        }
        namespace = System.getenv(CAMEL_HASHICORP_VAULT_NAMESPACE_ENV);
        if (ObjectHelper.isEmpty(token) && ObjectHelper.isEmpty(host)
                && ObjectHelper.isEmpty(port) && ObjectHelper.isEmpty(scheme) && ObjectHelper.isEmpty(namespace)) {
            HashicorpVaultConfiguration hashicorpVaultConfiguration = getCamelContext().getVaultConfiguration().hashicorp();
            if (ObjectHelper.isNotEmpty(hashicorpVaultConfiguration)) {
                token = hashicorpVaultConfiguration.getToken();
                host = hashicorpVaultConfiguration.getHost();
                port = hashicorpVaultConfiguration.getPort();
                scheme = hashicorpVaultConfiguration.getScheme();
                cloud = hashicorpVaultConfiguration.isCloud();
                if (hashicorpVaultConfiguration.isCloud()) {
                    namespace = hashicorpVaultConfiguration.getNamespace();
                }
            }
        }
        if (ObjectHelper.isNotEmpty(token) && ObjectHelper.isNotEmpty(host)
                && ObjectHelper.isNotEmpty(port) && ObjectHelper.isNotEmpty(scheme)) {
            VaultEndpoint vaultEndpoint = new VaultEndpoint();
            vaultEndpoint.setHost(host);
            vaultEndpoint.setPort(Integer.parseInt(port));
            vaultEndpoint.setScheme(scheme);

            client = new VaultTemplate(
                    vaultEndpoint,
                    new TokenAuthentication(token));
        } else {
            throw new RuntimeCamelException(
                    "Using the Hashicorp Properties Function requires setting Token, Host, port and scheme properties");
        }
    }

    private Network messageToNetwork(Message message) {
        Network network = message.getBody(Network.class);
        if (network == null) {
            Map headers = message.getHeaders();
            NetworkBuilder builder = Builders.network();

            StringHelper.notEmpty(message.getHeader(OpenstackConstants.NAME, String.class), "Name");
            builder.name(message.getHeader(OpenstackConstants.NAME, String.class));

            if (headers.containsKey(NeutronConstants.ADMIN_STATE_UP)) {
                builder.adminStateUp(message.getHeader(NeutronConstants.ADMIN_STATE_UP, Boolean.class));
            }

            if (headers.containsKey(NeutronConstants.NETWORK_TYPE)) {
                builder.networkType(message.getHeader(NeutronConstants.NETWORK_TYPE, NetworkType.class));
            }

            if (headers.containsKey(NeutronConstants.IS_SHARED)) {
                builder.isShared(message.getHeader(NeutronConstants.IS_SHARED, Boolean.class));
            }

            if (headers.containsKey(NeutronConstants.IS_ROUTER_EXTERNAL)) {
                builder.isRouterExternal(message.getHeader(NeutronConstants.IS_ROUTER_EXTERNAL, Boolean.class));
            }

            if (headers.containsKey(NeutronConstants.TENANT_ID)) {
                builder.tenantId(message.getHeader(NeutronConstants.TENANT_ID, String.class));
            }

            if (headers.containsKey(NeutronConstants.PHYSICAL_NETWORK)) {
                builder.physicalNetwork(message.getHeader(NeutronConstants.PHYSICAL_NETWORK, String.class));
            }

            if (headers.containsKey(NeutronConstants.SEGMENT_ID)) {
                builder.segmentId(message.getHeader(NeutronConstants.SEGMENT_ID, String.class));
            }

            network = builder.build();
        }

        return network;
    }

    protected ScheduledExecutorService getExecutorService(
            ScheduledExecutorService executorService, String executorServiceRef) {
        lock.lock();
        try {
            if (executorService == null || executorService.isShutdown()) {
                 
                 
                if (executorServiceRef != null) {
                    executorService = lookupByNameAndType(executorServiceRef, ScheduledExecutorService.class);
                    if (executorService == null) {
                        ExecutorServiceManager manager = camelContext.getExecutorServiceManager();
                        ThreadPoolProfile profile = manager.getThreadPoolProfile(executorServiceRef);
                        executorService = manager.newScheduledThreadPool(this, executorServiceRef, profile);
                    }
                    if (executorService == null) {
                        throw new IllegalArgumentException("ExecutorService " + executorServiceRef + " not found in registry.");
                    }
                } else {
                     
                     
                     
                    executorService = null;
                }
            }
            return executorService;
        } finally {
            lock.unlock();
        }
    }

    public Object unmarshal(final Exchange exchange, final InputStream inputStream) throws Exception {
        GzipCompressorInputStream unzipInput = null;

        OutputStreamBuilder osb = OutputStreamBuilder.withExchange(exchange);
        try {
            unzipInput = new GzipCompressorInputStream(inputStream, true);
            IOHelper.copy(unzipInput, osb);
            return osb.build();
        } finally {
             
            IOHelper.close(osb, unzipInput, inputStream);
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.servicebus.receiveMessages");

        if (message.getHeaders().containsKey(ServiceBusConstants.PARTITION_KEY)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.servicebus.partition." + message.getHeader(ServiceBusConstants.PARTITION_KEY, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(ServiceBusConstants.MESSAGE_ID, String.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        if (message.getHeaders().containsKey(ServiceBusConstants.CONTENT_TYPE)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE,
                    message.getHeaders().containsKey(ServiceBusConstants.CONTENT_TYPE));
        } else {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
        }
    }

                public void onComplete(Exchange exchange) {
                    final String key = exchange.getProperty(AWS2S3Constants.KEY, String.class);
                    try {
                        processCommit(exchange);
                    } finally {
                        if (key != null) {
                            getEndpoint().getInProgressRepository().remove(key);
                        }
                    }
                }

    private String getJavaDoc(JavaClassSource source, String fieldName, String classElement) {
        for (MethodSource<JavaClassSource> builder : source.getMethods()) {
            if (builder.getParameters().size() == 1 && builder.getName().equals(fieldName)) {
                String doc = getJavaDocText(loadJavaSource(classElement), builder);
                if (!Strings.isNullOrEmpty(doc)) {
                    return doc;
                }
            }
        }
        for (MethodSource<JavaClassSource> builder : source.getMethods()) {
            if (builder.getParameters().isEmpty() && builder.getName().equals(fieldName)) {
                String doc = getJavaDocText(loadJavaSource(classElement), builder);
                if (!Strings.isNullOrEmpty(doc)) {
                    return doc;
                }
            }
        }
        return null;
    }

    public Processor createProcessor() throws Exception {
        Policy policy = resolvePolicy();
        ObjectHelper.notNull(policy, "policy", definition);

         
        policy.beforeWrap(route, definition);

         
        Processor childProcessor = this.createChildProcessor(true);

         
        Processor target = policy.wrap(route, childProcessor);

        if (!(target instanceof Service)) {
             
             
            target = new WrapProcessor(target, childProcessor);
        }
        return target;
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, byte[].class, ca.uhn.hl7v2.model.Message.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toByteArray((ca.uhn.hl7v2.model.Message) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, ca.uhn.hl7v2.model.Message.class, byte[].class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toMessage((byte[]) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, ca.uhn.hl7v2.model.Message.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toMessage((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, ca.uhn.hl7v2.model.Message.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.hl7.HL7Converter.toString((ca.uhn.hl7v2.model.Message) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public static void doWithClasses(Class<?> clazz, ClassCallback cc) throws IllegalArgumentException {
         
        Class<?>[] classes = clazz.getDeclaredClasses();
        for (Class<?> aClazz : classes) {
            try {
                cc.doWith(aClazz);
            } catch (IllegalAccessException ex) {
                throw new IllegalStateException("Shouldn't be illegal to access class '" + aClazz.getName() + "': " + ex);
            }
        }
    }

    public BoxSharedLink createFileSharedLink(
            String fileId, BoxSharedLink.Access access, Date unshareDate,
            BoxSharedLink.Permissions permissions) {
        try {
            LOG.debug("Creating shared link for file(id={}) with access={} {}",
                    fileId, access, unshareDate == null
                            ? ""
                            : " unsharedDate=" + DateFormat.getDateTimeInstance().format(unshareDate)
                              + " permissions=" + permissions);

            BoxHelper.notNull(fileId, BoxHelper.FILE_ID);
            BoxHelper.notNull(access, "access");

            BoxFile file = new BoxFile(boxConnection, fileId);
            BoxSharedLinkRequest request = new BoxSharedLinkRequest();
            request.access(access).unsharedDate(unshareDate)
                    .permissions(permissions.getCanDownload(), permissions.getCanPreview(), permissions.getCanEdit());
            return file.createSharedLink(request);
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(BoxHelper.buildBoxApiErrorMessage(e), e);
        }
    }

        public Builder instance(Object instance) {
             
            if (instance instanceof Class) {
                this.beanType = (Class<?>) instance;
                this.instance = null;
            } else {
                this.beanType = null;
                this.instance = instance;
            }
            return this;
        }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((KafkaComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "brokers": getOrCreateConfiguration((KafkaComponent) component).setBrokers((java.lang.String) value); return true;
            case "clientId": getOrCreateConfiguration((KafkaComponent) component).setClientId((java.lang.String) value); return true;
            case "configuration": ((KafkaComponent) component).setConfiguration((org.apache.camel.component.kafka.KafkaConfiguration) value); return true;
            case "headerFilterStrategy": getOrCreateConfiguration((KafkaComponent) component).setHeaderFilterStrategy((org.apache.camel.spi.HeaderFilterStrategy) value); return true;
            case "reconnectBackoffMaxMs": getOrCreateConfiguration((KafkaComponent) component).setReconnectBackoffMaxMs((java.lang.Integer) value); return true;
            case "retryBackoffMaxMs": getOrCreateConfiguration((KafkaComponent) component).setRetryBackoffMaxMs((java.lang.Integer) value); return true;
            case "retryBackoffMs": getOrCreateConfiguration((KafkaComponent) component).setRetryBackoffMs((java.lang.Integer) value); return true;
            case "shutdownTimeout": getOrCreateConfiguration((KafkaComponent) component).setShutdownTimeout((int) value); return true;
            case "allowManualCommit": getOrCreateConfiguration((KafkaComponent) component).setAllowManualCommit((boolean) value); return true;
            case "autoCommitEnable": getOrCreateConfiguration((KafkaComponent) component).setAutoCommitEnable((boolean) value); return true;
            case "autoCommitIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setAutoCommitIntervalMs((java.lang.Integer) value); return true;
            case "autoOffsetReset": getOrCreateConfiguration((KafkaComponent) component).setAutoOffsetReset((java.lang.String) value); return true;
            case "batching": getOrCreateConfiguration((KafkaComponent) component).setBatching((boolean) value); return true;
            case "batchingIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setBatchingIntervalMs((java.lang.Integer) value); return true;
            case "breakOnFirstError": getOrCreateConfiguration((KafkaComponent) component).setBreakOnFirstError((boolean) value); return true;
            case "bridgeErrorHandler": ((KafkaComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "checkCrcs": getOrCreateConfiguration((KafkaComponent) component).setCheckCrcs((java.lang.Boolean) value); return true;
            case "commitTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setCommitTimeoutMs((java.lang.Long) value); return true;
            case "consumerRequestTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setConsumerRequestTimeoutMs((java.lang.Integer) value); return true;
            case "consumersCount": getOrCreateConfiguration((KafkaComponent) component).setConsumersCount((int) value); return true;
            case "fetchMaxBytes": getOrCreateConfiguration((KafkaComponent) component).setFetchMaxBytes((java.lang.Integer) value); return true;
            case "fetchMinBytes": getOrCreateConfiguration((KafkaComponent) component).setFetchMinBytes((java.lang.Integer) value); return true;
            case "fetchWaitMaxMs": getOrCreateConfiguration((KafkaComponent) component).setFetchWaitMaxMs((java.lang.Integer) value); return true;
            case "groupId": getOrCreateConfiguration((KafkaComponent) component).setGroupId((java.lang.String) value); return true;
            case "groupInstanceId": getOrCreateConfiguration((KafkaComponent) component).setGroupInstanceId((java.lang.String) value); return true;
            case "headerDeserializer": getOrCreateConfiguration((KafkaComponent) component).setHeaderDeserializer((org.apache.camel.component.kafka.serde.KafkaHeaderDeserializer) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setHeartbeatIntervalMs((java.lang.Integer) value); return true;
            case "keyDeserializer": getOrCreateConfiguration((KafkaComponent) component).setKeyDeserializer((java.lang.String) value); return true;
            case "maxPartitionFetchBytes": getOrCreateConfiguration((KafkaComponent) component).setMaxPartitionFetchBytes((java.lang.Integer) value); return true;
            case "maxPollIntervalMs": getOrCreateConfiguration((KafkaComponent) component).setMaxPollIntervalMs((java.lang.Integer) value); return true;
            case "maxPollRecords": getOrCreateConfiguration((KafkaComponent) component).setMaxPollRecords((java.lang.Integer) value); return true;
            case "offsetRepository": getOrCreateConfiguration((KafkaComponent) component).setOffsetRepository((org.apache.camel.spi.StateRepository) value); return true;
            case "partitionAssignor": getOrCreateConfiguration((KafkaComponent) component).setPartitionAssignor((java.lang.String) value); return true;
            case "pollOnError": getOrCreateConfiguration((KafkaComponent) component).setPollOnError((org.apache.camel.component.kafka.PollOnError) value); return true;
            case "pollTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setPollTimeoutMs((java.lang.Long) value); return true;
            case "preValidateHostAndPort": getOrCreateConfiguration((KafkaComponent) component).setPreValidateHostAndPort((boolean) value); return true;
            case "seekTo": getOrCreateConfiguration((KafkaComponent) component).setSeekTo((org.apache.camel.component.kafka.SeekPolicy) value); return true;
            case "sessionTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setSessionTimeoutMs((java.lang.Integer) value); return true;
            case "specificAvroReader": getOrCreateConfiguration((KafkaComponent) component).setSpecificAvroReader((boolean) value); return true;
            case "topicIsPattern": getOrCreateConfiguration((KafkaComponent) component).setTopicIsPattern((boolean) value); return true;
            case "valueDeserializer": getOrCreateConfiguration((KafkaComponent) component).setValueDeserializer((java.lang.String) value); return true;
            case "createConsumerBackoffInterval": ((KafkaComponent) component).setCreateConsumerBackoffInterval((long) value); return true;
            case "createConsumerBackoffMaxAttempts": ((KafkaComponent) component).setCreateConsumerBackoffMaxAttempts((int) value); return true;
            case "isolationLevel": getOrCreateConfiguration((KafkaComponent) component).setIsolationLevel((java.lang.String) value); return true;
            case "kafkaManualCommitFactory": ((KafkaComponent) component).setKafkaManualCommitFactory((org.apache.camel.component.kafka.consumer.KafkaManualCommitFactory) value); return true;
            case "pollExceptionStrategy": ((KafkaComponent) component).setPollExceptionStrategy((org.apache.camel.component.kafka.PollExceptionStrategy) value); return true;
            case "subscribeConsumerBackoffInterval": ((KafkaComponent) component).setSubscribeConsumerBackoffInterval((long) value); return true;
            case "subscribeConsumerBackoffMaxAttempts": ((KafkaComponent) component).setSubscribeConsumerBackoffMaxAttempts((int) value); return true;
            case "subscribeConsumerTopicMustExists": ((KafkaComponent) component).setSubscribeConsumerTopicMustExists((boolean) value); return true;
            case "batchWithIndividualHeaders": getOrCreateConfiguration((KafkaComponent) component).setBatchWithIndividualHeaders((boolean) value); return true;
            case "bufferMemorySize": getOrCreateConfiguration((KafkaComponent) component).setBufferMemorySize((java.lang.Integer) value); return true;
            case "compressionCodec": getOrCreateConfiguration((KafkaComponent) component).setCompressionCodec((java.lang.String) value); return true;
            case "connectionMaxIdleMs": getOrCreateConfiguration((KafkaComponent) component).setConnectionMaxIdleMs((java.lang.Integer) value); return true;
            case "deliveryTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setDeliveryTimeoutMs((java.lang.Integer) value); return true;
            case "enableIdempotence": getOrCreateConfiguration((KafkaComponent) component).setEnableIdempotence((boolean) value); return true;
            case "headerSerializer": getOrCreateConfiguration((KafkaComponent) component).setHeaderSerializer((org.apache.camel.component.kafka.serde.KafkaHeaderSerializer) value); return true;
            case "key": getOrCreateConfiguration((KafkaComponent) component).setKey((java.lang.String) value); return true;
            case "keySerializer": getOrCreateConfiguration((KafkaComponent) component).setKeySerializer((java.lang.String) value); return true;
            case "lazyStartProducer": ((KafkaComponent) component).setLazyStartProducer((boolean) value); return true;
            case "lingerMs": getOrCreateConfiguration((KafkaComponent) component).setLingerMs((java.lang.Integer) value); return true;
            case "maxBlockMs": getOrCreateConfiguration((KafkaComponent) component).setMaxBlockMs((java.lang.Integer) value); return true;
            case "maxInFlightRequest": getOrCreateConfiguration((KafkaComponent) component).setMaxInFlightRequest((java.lang.Integer) value); return true;
            case "maxRequestSize": getOrCreateConfiguration((KafkaComponent) component).setMaxRequestSize((java.lang.Integer) value); return true;
            case "metadataMaxAgeMs": getOrCreateConfiguration((KafkaComponent) component).setMetadataMaxAgeMs((java.lang.Integer) value); return true;
            case "metricReporters": getOrCreateConfiguration((KafkaComponent) component).setMetricReporters((java.lang.String) value); return true;
            case "metricsSampleWindowMs": getOrCreateConfiguration((KafkaComponent) component).setMetricsSampleWindowMs((java.lang.Integer) value); return true;
            case "noOfMetricsSample": getOrCreateConfiguration((KafkaComponent) component).setNoOfMetricsSample((java.lang.Integer) value); return true;
            case "partitioner": getOrCreateConfiguration((KafkaComponent) component).setPartitioner((java.lang.String) value); return true;
            case "partitionerIgnoreKeys": getOrCreateConfiguration((KafkaComponent) component).setPartitionerIgnoreKeys((boolean) value); return true;
            case "partitionKey": getOrCreateConfiguration((KafkaComponent) component).setPartitionKey((java.lang.Integer) value); return true;
            case "producerBatchSize": getOrCreateConfiguration((KafkaComponent) component).setProducerBatchSize((java.lang.Integer) value); return true;
            case "queueBufferingMaxMessages": getOrCreateConfiguration((KafkaComponent) component).setQueueBufferingMaxMessages((java.lang.Integer) value); return true;
            case "receiveBufferBytes": getOrCreateConfiguration((KafkaComponent) component).setReceiveBufferBytes((java.lang.Integer) value); return true;
            case "reconnectBackoffMs": getOrCreateConfiguration((KafkaComponent) component).setReconnectBackoffMs((java.lang.Integer) value); return true;
            case "requestRequiredAcks": getOrCreateConfiguration((KafkaComponent) component).setRequestRequiredAcks((java.lang.String) value); return true;
            case "requestTimeoutMs": getOrCreateConfiguration((KafkaComponent) component).setRequestTimeoutMs((java.lang.Integer) value); return true;
            case "retries": getOrCreateConfiguration((KafkaComponent) component).setRetries((java.lang.Integer) value); return true;
            case "sendBufferBytes": getOrCreateConfiguration((KafkaComponent) component).setSendBufferBytes((java.lang.Integer) value); return true;
            case "transacted": getOrCreateConfiguration((KafkaComponent) component).setTransacted((boolean) value); return true;
            case "transactionalId": getOrCreateConfiguration((KafkaComponent) component).setTransactionalId((java.lang.String) value); return true;
            case "useIterator": getOrCreateConfiguration((KafkaComponent) component).setUseIterator((boolean) value); return true;
            case "valueSerializer": getOrCreateConfiguration((KafkaComponent) component).setValueSerializer((java.lang.String) value); return true;
            case "workerPool": getOrCreateConfiguration((KafkaComponent) component).setWorkerPool((java.util.concurrent.ExecutorService) value); return true;
            case "workerPoolCoreSize": getOrCreateConfiguration((KafkaComponent) component).setWorkerPoolCoreSize((java.lang.Integer) value); return true;
            case "workerPoolMaxSize": getOrCreateConfiguration((KafkaComponent) component).setWorkerPoolMaxSize((java.lang.Integer) value); return true;
            case "recordMetadata": getOrCreateConfiguration((KafkaComponent) component).setRecordMetadata((boolean) value); return true;
            case "autowiredEnabled": ((KafkaComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "kafkaClientFactory": ((KafkaComponent) component).setKafkaClientFactory((org.apache.camel.component.kafka.KafkaClientFactory) value); return true;
            case "synchronous": getOrCreateConfiguration((KafkaComponent) component).setSynchronous((boolean) value); return true;
            case "healthCheckConsumerEnabled": ((KafkaComponent) component).setHealthCheckConsumerEnabled((boolean) value); return true;
            case "healthCheckProducerEnabled": ((KafkaComponent) component).setHealthCheckProducerEnabled((boolean) value); return true;
            case "interceptorClasses": getOrCreateConfiguration((KafkaComponent) component).setInterceptorClasses((java.lang.String) value); return true;
            case "schemaRegistryURL": getOrCreateConfiguration((KafkaComponent) component).setSchemaRegistryURL((java.lang.String) value); return true;
            case "kerberosBeforeReloginMinTime": getOrCreateConfiguration((KafkaComponent) component).setKerberosBeforeReloginMinTime((java.lang.Integer) value); return true;
            case "kerberosConfigLocation": getOrCreateConfiguration((KafkaComponent) component).setKerberosConfigLocation((java.lang.String) value); return true;
            case "kerberosInitCmd": getOrCreateConfiguration((KafkaComponent) component).setKerberosInitCmd((java.lang.String) value); return true;
            case "kerberosPrincipalToLocalRules": getOrCreateConfiguration((KafkaComponent) component).setKerberosPrincipalToLocalRules((java.lang.String) value); return true;
            case "kerberosRenewJitter": getOrCreateConfiguration((KafkaComponent) component).setKerberosRenewJitter((java.lang.Double) value); return true;
            case "kerberosRenewWindowFactor": getOrCreateConfiguration((KafkaComponent) component).setKerberosRenewWindowFactor((java.lang.Double) value); return true;
            case "saslJaasConfig": getOrCreateConfiguration((KafkaComponent) component).setSaslJaasConfig((java.lang.String) value); return true;
            case "saslKerberosServiceName": getOrCreateConfiguration((KafkaComponent) component).setSaslKerberosServiceName((java.lang.String) value); return true;
            case "saslMechanism": getOrCreateConfiguration((KafkaComponent) component).setSaslMechanism((java.lang.String) value); return true;
            case "securityProtocol": getOrCreateConfiguration((KafkaComponent) component).setSecurityProtocol((java.lang.String) value); return true;
            case "sslCipherSuites": getOrCreateConfiguration((KafkaComponent) component).setSslCipherSuites((java.lang.String) value); return true;
            case "sslContextParameters": getOrCreateConfiguration((KafkaComponent) component).setSslContextParameters((org.apache.camel.support.jsse.SSLContextParameters) value); return true;
            case "sslEnabledProtocols": getOrCreateConfiguration((KafkaComponent) component).setSslEnabledProtocols((java.lang.String) value); return true;
            case "sslEndpointAlgorithm": getOrCreateConfiguration((KafkaComponent) component).setSslEndpointAlgorithm((java.lang.String) value); return true;
            case "sslKeymanagerAlgorithm": getOrCreateConfiguration((KafkaComponent) component).setSslKeymanagerAlgorithm((java.lang.String) value); return true;
            case "sslKeyPassword": getOrCreateConfiguration((KafkaComponent) component).setSslKeyPassword((java.lang.String) value); return true;
            case "sslKeystoreLocation": getOrCreateConfiguration((KafkaComponent) component).setSslKeystoreLocation((java.lang.String) value); return true;
            case "sslKeystorePassword": getOrCreateConfiguration((KafkaComponent) component).setSslKeystorePassword((java.lang.String) value); return true;
            case "sslKeystoreType": getOrCreateConfiguration((KafkaComponent) component).setSslKeystoreType((java.lang.String) value); return true;
            case "sslProtocol": getOrCreateConfiguration((KafkaComponent) component).setSslProtocol((java.lang.String) value); return true;
            case "sslProvider": getOrCreateConfiguration((KafkaComponent) component).setSslProvider((java.lang.String) value); return true;
            case "sslTrustmanagerAlgorithm": getOrCreateConfiguration((KafkaComponent) component).setSslTrustmanagerAlgorithm((java.lang.String) value); return true;
            case "sslTruststoreLocation": getOrCreateConfiguration((KafkaComponent) component).setSslTruststoreLocation((java.lang.String) value); return true;
            case "sslTruststorePassword": getOrCreateConfiguration((KafkaComponent) component).setSslTruststorePassword((java.lang.String) value); return true;
            case "sslTruststoreType": getOrCreateConfiguration((KafkaComponent) component).setSslTruststoreType((java.lang.String) value); return true;
            case "useGlobalSslContextParameters": ((KafkaComponent) component).setUseGlobalSslContextParameters((boolean) value); return true;
            default: return false;
            }
        }

    protected void unInitReplyManager() {
        try {
            if (replyManager != null) {
                if (LOG.isDebugEnabled()) {
                    LOG.debug("Stopping RocketMQReplyManager: {} from processing replies from : {}", replyManager,
                            getEndpoint().getReplyToTopic());
                }
                ServiceHelper.stopService(replyManager);
            }
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        } finally {
            started.set(false);
        }
    }

    public void marshal(final Exchange exchange, final Object graph, final OutputStream stream) throws Exception {
        String filename = null;

        String filepath = exchange.getIn().getHeader(FILE_NAME, String.class);
        Long fileLength = exchange.getIn().getHeader(FILE_LENGTH, Long.class);
        if (filepath != null) {
            Path filenamePath = Paths.get(filepath).getFileName();
            if (filenamePath != null) {
                filename = filenamePath.toString();  
            }
        }
        if (filename == null) {
             
            filename = filepath = StringHelper.sanitize(exchange.getIn().getMessageId());
        }
        InputStream is = exchange.getContext().getTypeConverter().mandatoryConvertTo(InputStream.class, exchange, graph);
        if (fileLength == null) {
            fileLength = (long) is.available();
        }

        ZipArchiveOutputStream zos = new ZipArchiveOutputStream(stream);
        if (preservePathElements) {
            createZipEntries(zos, filepath, fileLength);
        } else {
            createZipEntries(zos, filename, fileLength);
        }

        try {
            IOHelper.copy(is, zos);
        } finally {
            zos.closeArchiveEntry();
            IOHelper.close(is, zos);
        }

        String newFilename = filename + ".zip";
        exchange.getMessage().setHeader(FILE_NAME, newFilename);
    }

    public ProtocolEncoder getEncoder(IoSession session) throws Exception {
        return new ProtocolEncoder() {

            public void encode(IoSession session, Object message, ProtocolEncoderOutput out) throws Exception {
                IoBuffer buf = toIoBuffer(message);
                buf.flip();
                out.write(buf);
            }

            public void dispose(IoSession session) throws Exception {
                 
            }
        };
    }

    private void doCreateOrUpdateNode(Exchange exchange, String operationName, Function<Resource<Node>, Node> operation) {
        String nodeName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NODE_NAME, String.class);
        NodeSpec nodeSpec = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NODE_SPEC, NodeSpec.class);
        if (ObjectHelper.isEmpty(nodeName)) {
            LOG.error("{} a specific node require specify a node name", operationName);
            throw new IllegalArgumentException(String.format("%s a specific node require specify a node name", operationName));
        }
        if (ObjectHelper.isEmpty(nodeSpec)) {
            LOG.error("{} a specific node require specify a node spec bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific node require specify a node spec bean", operationName));
        }
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PODS_LABELS, Map.class);
        Node nodeCreating = new NodeBuilder().withNewMetadata().withName(nodeName).withLabels(labels).endMetadata()
                .withSpec(nodeSpec).build();
        Node node = operation.apply(getEndpoint().getKubernetesClient().nodes().resource(nodeCreating));

        prepareOutboundMessage(exchange, node);
    }

    private void processCloseJob(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        JobInfo jobBody;
        String jobId;
        jobBody = exchange.getIn().getBody(JobInfo.class);
        if (jobBody != null) {
            jobId = jobBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.closeJob(jobId, determineHeaders(exchange), new BulkApiClient.JobInfoResponseCallback() {
            @Override
            public void onResponse(JobInfo jobInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, jobInfo, headers, ex, callback);
            }
        });
    }

    public Exchange createExchange(MqttMessage mqttMessage, String topic) {
        Exchange exchange = createExchange(true);

        PahoMessage paho = new PahoMessage(exchange.getContext(), mqttMessage);
        paho.setBody(mqttMessage.getPayload());
        paho.setHeader(PahoConstants.MQTT_TOPIC, topic);
        paho.setHeader(PahoConstants.MQTT_QOS, mqttMessage.getQos());

        exchange.setIn(paho);
        if (getEndpoint().getConfiguration().isManualAcksEnabled()) {
            exchange.getExchangeExtension().addOnCompletion(new Synchronization() {
                @Override
                public void onComplete(Exchange exchange) {
                    try {
                        PahoConsumer.this.client.messageArrivedComplete(mqttMessage.getId(), mqttMessage.getQos());
                    } catch (MqttException e) {
                        LOG.warn("Failed to commit message with ID {} due to MqttException.", mqttMessage.getId());
                    }
                }

                @Override
                public void onFailure(Exchange exchange) {
                    LOG.error("Rollback due to error processing Exchange ID: {}", exchange.getExchangeId(),
                            exchange.getException());
                }
            });
        }
        return exchange;
    }

    private void updateGroup(Exchange exchange, ClientConfigurations clientConfigurations) {
         
        Object body = exchange.getMessage().getBody();
        KeystoneUpdateGroupOption groupOption;
        if (body instanceof KeystoneUpdateGroupOption) {
            groupOption = (KeystoneUpdateGroupOption) body;
        } else if (body instanceof String) {
            String strBody = (String) body;
            try {
                groupOption = new ObjectMapper().readValue(strBody, KeystoneUpdateGroupOption.class);
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("String request body must be a valid JSON with the proper keys");
            }
        } else {
            throw new IllegalArgumentException(
                    "Exchange body is mandatory and should be a valid JSON string or KeystoneUpdateGroupOption object");
        }

         
        if (ObjectHelper.isEmpty(clientConfigurations.getGroupId())) {
            if (LOG.isErrorEnabled()) {
                LOG.error("No group id given");
            }
            throw new IllegalArgumentException("Group id is mandatory to update group");
        }

         
        KeystoneUpdateGroupRequestBody requestBody = new KeystoneUpdateGroupRequestBody()
                .withGroup(groupOption);
        KeystoneUpdateGroupRequest request = new KeystoneUpdateGroupRequest()
                .withBody(requestBody)
                .withGroupId(clientConfigurations.getGroupId());
        KeystoneUpdateGroupResponse response = iamClient.keystoneUpdateGroup(request);
        exchange.getMessage().setBody(gson.toJson(response.getGroup()));
    }

    private Stream<? extends Member> findFieldsForClass(Class<?> c) {
        XmlAccessType accessType;
        if (c.getAnnotation(XmlAccessorType.class) != null) {
            accessType = c.getAnnotation(XmlAccessorType.class).value();
        } else {
            accessType = XmlAccessType.PUBLIC_MEMBER;
        }
        if (accessType == XmlAccessType.PROPERTY || accessType == XmlAccessType.NONE) {
            return Stream
                    .of(c.getDeclaredFields())
                    .filter(f -> f.getAnnotation(XmlAttribute.class) != null || f.getAnnotation(XmlElement.class) != null
                            || f.getAnnotation(XmlElementRef.class) != null || f.getAnnotation(XmlValue.class) != null)
                    .sorted(Comparator.comparing(Field::getName));
        } else {
            return Stream.of(c.getDeclaredFields())
                    .filter(f -> !Modifier.isTransient(f.getModifiers()) && !Modifier.isStatic(f.getModifiers()))
                    .filter(f -> Modifier.isPublic(f.getModifiers()) || accessType == XmlAccessType.FIELD)
                    .filter(f -> f.getAnnotation(XmlTransient.class) == null)
                    .sorted(Comparator.comparing(Field::getName));
        }
    }

    private ScrollResponse<TDocument> scrollSearch() {
        ScrollResponse<TDocument> scrollResponse;
        try {
            ScrollRequest searchScrollRequest = new ScrollRequest.Builder()
                    .scroll(Time.of(b -> b.time(String.format("%sms", scrollKeepAliveMs))))
                    .scrollId(scrollId)
                    .build();

            scrollResponse = esClient.scroll(searchScrollRequest, documentClass);
            requestCount++;
        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
        return scrollResponse;
    }

    public void execute() throws MojoExecutionException {
        File camelDir = findCamelDirectory(baseDir, "core/camel-util");
        if (camelDir == null) {
            getLog().debug("No core/camel-util folder found, skipping execution");
            return;
        }
        List<Path> jsonFiles;
        try (Stream<Path> stream = PackageHelper.findJsonFiles(jsonDir.toPath())) {
            jsonFiles = stream.toList();
        }
        Set<String> secrets = new TreeSet<>();

        for (Path file : jsonFiles) {
            final String name = PackageHelper.asName(file);

            try {
                String json = PackageHelper.loadText(file.toFile());
                Object jo = Jsoner.deserialize(json);
                JsonObject obj;
                if (jo instanceof JsonObject) {
                    obj = (JsonObject) jo;
                } else {
                    continue;
                }

                boolean isComponent = obj.getMap("component") != null;
                boolean isDataFormat = !isComponent && obj.getMap("dataformat") != null;
                boolean isLanguage = !isComponent && !isDataFormat && obj.getMap("language") != null;

                 
                if (!isComponent && !isDataFormat && !isLanguage) {
                    continue;
                }

                if (isComponent) {
                    ComponentModel cm = JsonMapper.generateComponentModel(json);
                    cm.getComponentOptions().forEach(o -> {
                        if (o.isSecret()) {
                             
                            String key = o.getName().toLowerCase(Locale.ENGLISH);
                            key = key.replace("-", "");
                            secrets.add(key);
                        }
                    });
                } else if (isDataFormat) {
                    DataFormatModel dm = JsonMapper.generateDataFormatModel(json);
                    dm.getOptions().forEach(o -> {
                        if (o.isSecret()) {
                             
                            String key = o.getName().toLowerCase(Locale.ENGLISH);
                            key = key.replace("-", "");
                            secrets.add(key);
                        }
                    });
                } else if (isLanguage) {
                    LanguageModel lm = JsonMapper.generateLanguageModel(json);
                    lm.getOptions().forEach(o -> {
                        if (o.isSecret()) {
                             
                            String key = o.getName().toLowerCase(Locale.ENGLISH);
                            key = key.replace("-", "");
                            secrets.add(key);
                        }
                    });
                }
            } catch (Exception e) {
                throw new MojoExecutionException("Error loading json: " + name, e);
            }
        }

         
        secrets.addAll(Arrays.asList(EXTRA_KEYS));

        getLog().info("There are " + secrets.size()
                      + " distinct secret options across all the Camel components/dataformats/languages");

        try {
            boolean updated = updateSensitiveHelperKeys(camelDir, secrets);
            updated |= updateSensitiveHelperPatterns(camelDir, secrets);
            if (updated) {
                getLog().info("Updated camel-util/src/main/java/org/apache/camel/util/SensitiveUtils.java file");
            } else {
                getLog().debug("No changes to camel-util/src/main/java/org/apache/camel/util/SensitiveUtils.java file");
            }
        } catch (Exception e) {
            throw new MojoExecutionException("Error updating SensitiveUtils.java", e);
        }

        try {
            updateSensitiveJsonSchema(baseDir, secrets);
        } catch (Exception e) {
            throw new MojoExecutionException("Error updating sensitive-keys.json", e);
        }
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.mongodb.ReadPreference.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toReadPreference((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, com.mongodb.WriteConcern.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.component.mongodb.gridfs.GridFsConverter.toWriteConcern((java.lang.String) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

    public MediaSizeName selectMediaSizeNameNA(String size) {
        if (size.equalsIgnoreCase("na_letter")) {
            mediaSizeName = MediaSizeName.NA_LETTER;
        } else if (size.equalsIgnoreCase("na_legal")) {
            mediaSizeName = MediaSizeName.NA_LEGAL;
        } else if (size.equalsIgnoreCase("executive")) {
            mediaSizeName = MediaSizeName.EXECUTIVE;
        } else if (size.equalsIgnoreCase("ledger")) {
            mediaSizeName = MediaSizeName.LEDGER;
        } else if (size.equalsIgnoreCase("tabloid")) {
            mediaSizeName = MediaSizeName.TABLOID;
        } else if (size.equalsIgnoreCase("invoice")) {
            mediaSizeName = MediaSizeName.INVOICE;
        } else if (size.equalsIgnoreCase("folio")) {
            mediaSizeName = MediaSizeName.FOLIO;
        } else if (size.equalsIgnoreCase("quarto")) {
            mediaSizeName = MediaSizeName.QUARTO;
        } else if (size.equalsIgnoreCase("japanese_postcard")) {
            mediaSizeName = MediaSizeName.JAPANESE_POSTCARD;
        } else if (size.equalsIgnoreCase("oufuko_postcard")) {
            mediaSizeName = MediaSizeName.JAPANESE_DOUBLE_POSTCARD;
        } else if (size.equalsIgnoreCase("a")) {
            mediaSizeName = MediaSizeName.A;
        } else if (size.equalsIgnoreCase("b")) {
            mediaSizeName = MediaSizeName.B;
        } else if (size.equalsIgnoreCase("c")) {
            mediaSizeName = MediaSizeName.C;
        } else if (size.equalsIgnoreCase("d")) {
            mediaSizeName = MediaSizeName.D;
        } else if (size.equalsIgnoreCase("e")) {
            mediaSizeName = MediaSizeName.E;
        } else if (size.equalsIgnoreCase("iso_designated_long")) {
            mediaSizeName = MediaSizeName.ISO_DESIGNATED_LONG;
        } else if (size.equalsIgnoreCase("italian_envelope")) {
            mediaSizeName = MediaSizeName.ITALY_ENVELOPE;
        } else if (size.equalsIgnoreCase("monarch_envelope")) {
            mediaSizeName = MediaSizeName.MONARCH_ENVELOPE;
        } else if (size.equalsIgnoreCase("personal_envelope")) {
            mediaSizeName = MediaSizeName.PERSONAL_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_number_9_envelope")) {
            mediaSizeName = MediaSizeName.NA_NUMBER_9_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_number_10_envelope")) {
            mediaSizeName = MediaSizeName.NA_NUMBER_10_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_number_11_envelope")) {
            mediaSizeName = MediaSizeName.NA_NUMBER_11_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_number_12_envelope")) {
            mediaSizeName = MediaSizeName.NA_NUMBER_12_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_number_14_envelope")) {
            mediaSizeName = MediaSizeName.NA_NUMBER_14_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_6x9_envelope")) {
            mediaSizeName = MediaSizeName.NA_6X9_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_7x9_envelope")) {
            mediaSizeName = MediaSizeName.NA_7X9_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_9x11_envelope")) {
            mediaSizeName = MediaSizeName.NA_9X11_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_9x12_envelope")) {
            mediaSizeName = MediaSizeName.NA_9X12_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_10x13_envelope")) {
            mediaSizeName = MediaSizeName.NA_10X13_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_10x14_envelope")) {
            mediaSizeName = MediaSizeName.NA_10X14_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_10x15_envelope")) {
            mediaSizeName = MediaSizeName.NA_10X15_ENVELOPE;
        } else if (size.equalsIgnoreCase("na_5x7")) {
            mediaSizeName = MediaSizeName.NA_5X7;
        } else if (size.equalsIgnoreCase("na_8x10")) {
            mediaSizeName = MediaSizeName.NA_8X10;
        } else {
            mediaSizeName = MediaSizeName.NA_LETTER;
        }

        return mediaSizeName;
    }

                public void onComplete(Exchange exchange) {
                     
                    Boolean close;
                    if (ExchangeHelper.isOutCapable(exchange)) {
                        close = exchange.getOut().getHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, Boolean.class);
                    } else {
                        close = exchange.getIn().getHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, Boolean.class);
                    }

                     
                    boolean disconnect = getConfiguration().isDisconnect();
                    if (close != null) {
                        disconnect = close;
                    }

                    if (disconnect) {
                        LOG.trace("Closing channel {} as routing the Exchange is done", channel);
                        NettyHelper.close(channel);
                    }

                    releaseChannel(channelFuture);
                }

    private boolean sleep() {
        LOG.trace("Exclusive read lock not granted. Sleeping for {} millis.", checkInterval);
        try {
            Thread.sleep(checkInterval);
            return false;
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            LOG.debug("Sleep interrupted while waiting for exclusive read lock, so breaking out");
            return true;
        }
    }

    private void loadProperties(Map<String, Object> properties, Optional<?> optional, PropertyConfigurer configurer) {
        BeanIntrospection beanIntrospection = PluginHelper.getBeanIntrospection(camelContext);
        optional.ifPresent(bean -> {
            if (configurer instanceof ExtendedPropertyConfigurerGetter) {
                ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
                Map<String, Object> types = getter.getAllOptions(bean);
                types.forEach((k, t) -> {
                    Object value = getter.getOptionValue(bean, k, true);
                    if (value != null) {
                        properties.put(k, value);
                    }
                });
            } else {
                 
                beanIntrospection.getProperties(bean, properties, null, false);
            }
        });
    }

    Consumer doCreateConsumer(
            CamelContext camelContext, Processor processor, String verb, String basePath, String uriTemplate,
            RestConfiguration configuration, Map<String, Object> parameters, boolean api)
            throws Exception {

        String path = basePath;
        if (uriTemplate != null) {
             
            if (uriTemplate.startsWith("/")) {
                path = path + uriTemplate;
            } else {
                path = path + "/" + uriTemplate;
            }
        }
        path = FileUtil.stripLeadingSeparator(path);

        String scheme = "http";
        String host = "";
        int port = 0;

         
        RestConfiguration config = configuration;
        if (config == null) {
            config = CamelContextHelper.getRestConfiguration(getCamelContext(), "jetty");
        }

        if (config.getScheme() != null) {
            scheme = config.getScheme();
        }
        if (config.getHost() != null) {
            host = config.getHost();
        }
        int num = config.getPort();
        if (num > 0) {
            port = num;
        }

         
        String contextPath = config.getContextPath();
        if (ObjectHelper.isNotEmpty(contextPath)) {
            contextPath = FileUtil.stripTrailingSeparator(contextPath);
            contextPath = FileUtil.stripLeadingSeparator(contextPath);
            if (ObjectHelper.isNotEmpty(contextPath)) {
                path = contextPath + "/" + path;
            }
        }

         
        if (ObjectHelper.isEmpty(host)) {
            host = RestComponentHelper.resolveRestHostName(host, config);
        }

        Map<String, Object> map = RestComponentHelper.initRestEndpointProperties("jetty", config);

        boolean cors = config.isEnableCORS();
        if (cors) {
             
            map.put("optionsEnabled", "true");
        }

        if (api) {
            map.put("matchOnUriPrefix", "true");
        }

        RestComponentHelper.addHttpRestrictParam(map, verb, cors);

        String url = RestComponentHelper.createRestConsumerUrl("jetty", scheme, host, port, path, map);

        JettyHttpEndpoint endpoint = (JettyHttpEndpoint) camelContext.getEndpoint(url, parameters);

        boolean binding = map.containsKey("httpBindingRef") || map.containsKey("httpBinding");

        if (!binding) {
             
            endpoint.setHttpBinding(new JettyRestHttpBinding(endpoint));
             
            endpoint.setEnableMultipartFilter(false);
        }

         
        Consumer consumer = endpoint.createConsumer(processor);
        if (config.getConsumerProperties() != null && !config.getConsumerProperties().isEmpty()) {
            setProperties(camelContext, consumer, config.getConsumerProperties());
        }

         
        ServiceHelper.startService(endpoint);

        return consumer;
    }

    public static JsonObject asJsonObject(MainModel model) {
        JsonObject json = new JsonObject();
        JsonArray groups = new JsonArray();
        for (MainGroupModel group : model.getGroups()) {
            JsonObject j = new JsonObject();
            j.put("name", group.getName());
            if (group.getDescription() != null) {
                j.put("description", group.getDescription());
            }
            if (group.getSourceType() != null) {
                j.put("sourceType", group.getSourceType());
            }
            groups.add(j);
        }
        json.put("groups", groups);
        JsonArray props = new JsonArray();
        for (MainOptionModel prop : model.getOptions()) {
            JsonObject j = new JsonObject();
            j.put("name", prop.getName());
            j.put("required", prop.isRequired());
            if (prop.getDescription() != null) {
                j.put("description", prop.getDescription());
            }
            if (prop.getGroup() != null) {
                j.put("group", prop.getGroup());
            }
            if (prop.getLabel() != null) {
                j.put("label", prop.getLabel());
            }
            if (prop.getSourceType() != null) {
                j.put("sourceType", prop.getSourceType());
            }
            j.put("type", prop.getType());
            j.put("javaType", prop.getJavaType());
            if (prop.getDefaultValue() != null) {
                j.put("defaultValue", prop.resolveDefaultValue());
            }
            j.put("secret", prop.isSecret());
            if (prop.getEnums() != null) {
                j.put("enum", prop.getEnums());
            }
            if (prop.isDeprecated()) {
                j.put("deprecated", prop.isDeprecated());
            }
            if (prop.isAutowired()) {
                j.put("autowired", prop.isAutowired());
            }
            props.add(j);
        }
        json.put("properties", props);
        return json;
    }

    private SslHandler configureServerSSLOnDemand() {
        if (!consumer.getConfiguration().isSsl()) {
            return null;
        }

        if (consumer.getConfiguration().getSslHandler() != null) {
            return consumer.getConfiguration().getSslHandler();
        } else if (sslContext != null) {
            SSLEngine engine = sslContext.createSSLEngine();
            engine.setUseClientMode(consumer.getConfiguration().isClientMode());
            engine.setNeedClientAuth(consumer.getConfiguration().isNeedClientAuth());
            if (consumer.getConfiguration().isHostnameVerification()) {
                SSLParameters sslParams = engine.getSSLParameters();
                sslParams.setEndpointIdentificationAlgorithm("HTTPS");
                engine.setSSLParameters(sslParams);
            }
            if (consumer.getConfiguration().getSslContextParameters() == null) {
                 
                engine.setEnabledProtocols(consumer.getConfiguration().getEnabledProtocols().split(","));
            }
            return new SslHandler(engine);
        }

        return null;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        OpenAIConfiguration configuration = new OpenAIConfiguration();

        if (apiKey != null) {
            configuration.setApiKey(apiKey);
        }
        if (baseUrl != null) {
            configuration.setBaseUrl(baseUrl);
        }
        if (model != null) {
            configuration.setModel(model);
        }

        OpenAIEndpoint endpoint = new OpenAIEndpoint(uri, this, configuration);
         
        endpoint.setOperation(remaining);
        setProperties(endpoint, parameters);

        return endpoint;
    }

    public Set<String> scan(CamelContext camelContext) {
        if (useRecovery) {
            LOG.trace("Scanning for exchanges to recover in {} context", camelContext.getName());
            Set<String> scanned = Collections.unmodifiableSet(persistedCache.keySet());
            LOG.trace("Found {} keys for exchanges to recover in {} context", scanned.size(), camelContext.getName());
            return scanned;
        } else {
            LOG.warn(
                    "What for to run recovery scans in {} context while repository {} is running in non-recoverable aggregation repository mode?!",
                    camelContext.getName(), mapName);
            return Collections.emptySet();
        }
    }

    private String getUri(Row r) {
        String u = r.uri;
        if (shortUri) {
            int pos = u.indexOf('?');
            if (pos > 0) {
                u = u.substring(0, pos);
            }
        }
        return u;
    }

    private void processGetQueryResultIds(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String jobId;
        BatchInfo batchBody;
        String batchId;
        batchBody = exchange.getIn().getBody(BatchInfo.class);
        if (batchBody != null) {
            jobId = batchBody.getJobId();
            batchId = batchBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            batchId = getParameter(BATCH_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getQueryResultIds(jobId, batchId, determineHeaders(exchange), new BulkApiClient.QueryResultIdsCallback() {
            @Override
            public void onResponse(List<String> ids, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, ids, headers, ex, callback);
            }
        });
    }

    public Client getClient() {
        if (this.client == null) {
            lock.lock();
            try {
                if (this.client == null) {
                    this.client = this.configuration.getClient();

                    if (this.client == null) {
                        this.client = createClient();
                    }
                }
            } finally {
                lock.unlock();
            }
        }

        return this.client;
    }

    public void createBatch(
            InputStream batchStream, String jobId, ContentType contentTypeEnum, Map<String, List<String>> headers,
            final BatchInfoResponseCallback callback) {
        final Request post = getRequest(HttpMethod.POST, batchUrl(jobId, null), headers);
        post.body(new InputStreamRequestContent(batchStream));
        post.headers(mutable -> mutable.add(
                new HttpField(
                        HttpHeader.CONTENT_TYPE,
                        getContentType(contentTypeEnum) + ";charset=" + StandardCharsets.UTF_8.name())));

         
        doHttpRequest(post, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                BatchInfo value = null;
                try {
                    value = unmarshalResponse(response, post, BatchInfo.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(value, headers, ex);
            }
        });
    }

    private void doInsert(Exchange exchange, String tableName) throws KuduException {
        LOG.trace("Insert on table {}", tableName);
        KuduClient connection = endpoint.getKuduClient();
        KuduTable table = connection.openTable(tableName);

        Insert insert = table.newInsert();
        PartialRow row = insert.getRow();

        Map<?, ?> rows = exchange.getIn().getBody(Map.class);
        for (Map.Entry<?, ?> entry : rows.entrySet()) {
            final String colName = entry.getKey().toString();
            final Object value = entry.getValue();
             
             
            if (table.getSchema().getColumn(colName) != null) {
                row.addObject(colName, value);
            }
        }

        connection.newSession().apply(insert);
    }

    protected void postProcessFactoryParameters(CamelContext camelContext, Map<String, Object> parameters) throws Exception {
        List<String> servers = List.class.cast(parameters.get("servers"));

        if (ObjectHelper.isNotEmpty(servers)) {
            final ListIterator<String> it = servers.listIterator();
            while (it.hasNext()) {
                it.set(camelContext.resolvePropertyPlaceholders(it.next()));
            }

            parameters.put("servers", servers);
        }
    }

    public static Map<String, Object> asMap(Node node) {
        if (node == null) {
            return null;
        }

        final MappingNode mn = asMappingNode(node);
        final Map<String, Object> answer = new HashMap<>();

        for (NodeTuple tuple : mn.getValue()) {
            final String key = asText(tuple.getKeyNode());
            final Node val = tuple.getValueNode();

            switch (val.getNodeType()) {
                case SCALAR:
                    answer.put(StringHelper.dashToCamelCase(key), asText(val));
                    break;
                case MAPPING:
                    answer.put(StringHelper.dashToCamelCase(key), asMap(val));
                    break;
                default:
                    throw new UnsupportedNodeTypeException(val);
            }
        }

        return answer;
    }

    String lookup(String name, String key, String defaultValue) {
        String answer = null;
        Secret sec = getClient().secrets().withName(name).get();
        if (sec != null) {
             
            answer = sec.getStringData() != null ? sec.getStringData().get(key) : null;
            if (answer == null) {
                 
                answer = sec.getData() != null ? sec.getData().get(key) : null;
                if (answer != null) {
                    byte[] data = Base64.getDecoder().decode(answer);
                    if (data != null) {
                        answer = handleData(key, data);
                    }
                }
            }
        }
        if (answer == null) {
            return defaultValue;
        }

        return answer;
    }

    String lookup(String name, String key, String defaultValue) {
        String answer = null;
        Secret sec = getClient().secrets().withName(name).get();
        if (sec != null) {
             
            answer = sec.getStringData() != null ? sec.getStringData().get(key) : null;
            if (answer == null) {
                 
                answer = sec.getData() != null ? sec.getData().get(key) : null;
                if (answer != null) {
                    byte[] data = Base64.getDecoder().decode(answer);
                    if (data != null) {
                        answer = handleData(key, data);
                    }
                }
            }
        }
        if (answer == null) {
            return defaultValue;
        }

        return answer;
    }

    public InputStream getResourceAsStream(String name) {
        InputStream is = null;
        if (classLoader != null) {
            is = classLoader.getResourceAsStream(name);
        }
        if (is == null) {
            is = DefaultCamelCatalog.class.getClassLoader().getResourceAsStream(name);
        }
        return is;
    }

    private XPathFunction createOutHeaderFunction() {
        return new XPathFunction() {
            @SuppressWarnings("rawtypes")
            public Object evaluate(List list) throws XPathFunctionException {
                if (exchange.get() != null && !list.isEmpty()) {
                    Object value = list.get(0);
                    if (value != null) {
                        String headerText = exchange.get().getContext().getTypeConverter().convertTo(String.class, value);
                        return exchange.get().getOut().getHeader(headerText);
                    }
                }
                return null;
            }
        };
    }

    protected void doListPersistentVolumesClaimsByLabels(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUMES_CLAIMS_LABELS, Map.class);
        PersistentVolumeClaimList pvcList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Listing PersistentVolumeClaims by labels requires specifying labels");
            throw new IllegalArgumentException("Listing PersistentVolumeClaims by labels requires specifying labels");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            pvcList = getEndpoint().getKubernetesClient().persistentVolumeClaims().inAnyNamespace().withLabels(labels).list();
        } else {
            pvcList = getEndpoint().getKubernetesClient().persistentVolumeClaims().inNamespace(namespace).withLabels(labels)
                    .list();
        }

        prepareOutboundMessage(exchange, pvcList.getItems());
    }

    public boolean matches(Exchange exchange) {
        final Object value = evaluate(exchange, Object.class);

        if (value instanceof BooleanNode) {
            return ((BooleanNode) value).asBoolean();
        }
        if (value instanceof Collection) {
            return !((Collection<?>) value).isEmpty();
        }

        return false;
    }

    protected void configureDefaultCodecFactory(String type, IoService service, MinaConfiguration configuration) {
        if (configuration.isTextline()) {
            Charset charset = getEncodingParameter(type, configuration);
            LineDelimiter delimiter = getLineDelimiterParameter(configuration.getTextlineDelimiter());
            MinaTextLineCodecFactory codecFactory = new MinaTextLineCodecFactory(charset, delimiter);
            if (configuration.getEncoderMaxLineLength() > 0) {
                codecFactory.setEncoderMaxLineLength(configuration.getEncoderMaxLineLength());
            }
            if (configuration.getDecoderMaxLineLength() > 0) {
                codecFactory.setDecoderMaxLineLength(configuration.getDecoderMaxLineLength());
            }
            addCodecFactory(service, codecFactory);
            if (LOG.isDebugEnabled()) {
                LOG.debug("{}: Using TextLineCodecFactory: {} using encoding: {} line delimiter: {}({})",
                        type, codecFactory, charset, configuration.getTextlineDelimiter(), delimiter);
                LOG.debug("Encoder maximum line length: {}. Decoder maximum line length: {}",
                        codecFactory.getEncoderMaxLineLength(), codecFactory.getDecoderMaxLineLength());
            }
        } else {
            ObjectSerializationCodecFactory codecFactory = new ObjectSerializationCodecFactory();
            if (configuration.getObjectCodecPattern() != null) {
                String[] arr = configuration.getObjectCodecPattern().split(",");
                codecFactory.accept(arr);
            }
            addCodecFactory(service, codecFactory);
            LOG.debug("{}: Using ObjectSerializationCodecFactory: {}", type, codecFactory);
        }
    }

    private String releaseDate(Row r) {
        try {
            if (r.releaseDate != null) {
                SimpleDateFormat sdf = new SimpleDateFormat(YYYY_MM_DD);
                Date d = sdf.parse(r.releaseDate);
                SimpleDateFormat sdf2 = new SimpleDateFormat(dateFormat, Locale.US);
                return sdf2.format(d);
            }
        } catch (Exception e) {
             
        }
        return r.releaseDate != null ? r.releaseDate : "";
    }

    public void setupJaxb(
            CamelContext camelContext, RestConfiguration config,
            String type, Class<?> typeClass, String outType, Class<?> outTypeClass,
            DataFormat jaxb, DataFormat outJaxb)
            throws Exception {
         
        PropertyConfigurer configurer = PluginHelper.getConfigurerResolver(camelContext)
                .resolvePropertyConfigurer("jaxb-dataformat-configurer", camelContext);
        if (configurer == null) {
            throw new IllegalStateException("Cannot find configurer for dataformat: jaxb");
        }

         
         
         

        PropertyBindingSupport.Builder builder = PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withConfigurer(configurer)
                .withTarget(jaxb);

        final String typeName = getTypeName(type, typeClass);
        if (typeName != null) {
            builder.withProperty("contextPath", typeName);
            builder.withProperty("contextPathIsClassName", "true");
        }

        setAdditionalConfiguration(config, "xml.in.", builder);
        builder.bind();

         
         
         

        PropertyBindingSupport.Builder outBuilder = PropertyBindingSupport.build()
                .withCamelContext(camelContext)
                .withConfigurer(configurer)
                .withTarget(outJaxb);

        final String outTypeName = getOutTypeName(outType, outTypeClass, typeName);

        if (outTypeName != null) {
            outBuilder.withProperty("contextPath", outTypeName);
            outBuilder.withProperty("contextPathIsClassName", "true");
        }

        setAdditionalConfiguration(config, "xml.out.", outBuilder);
        outBuilder.bind();
    }

    public void run() {
        startingTime = Instant.now();
        final CountDownLatch isWatchClosed = new CountDownLatch(1);
        Watch watch = kubernetesClient.secrets().inNamespace(kubernetesClient.getNamespace()).watch(new Watcher<>() {
            @Override
            public void eventReceived(Action action, Secret secret) {
                switch (action.name()) {
                    case "MODIFIED":
                        if (isReloadEnabled()) {
                            if (matchSecret(secret.getMetadata().getName())) {
                                LOG.info("Update for Kubernetes Secret: {} detected, triggering CamelContext reload",
                                        secret.getMetadata().getName());
                                ContextReloadStrategy reload = camelContext.hasService(ContextReloadStrategy.class);
                                if (reload != null) {
                                     
                                    reload.onReload(this);
                                }
                            }
                        }
                        break;
                    default:
                        LOG.debug("Not watched event {}", action.name());
                }
            }

            @Override
            public void onClose(WatcherException e) {
                isWatchClosed.countDown();
            }
        });

         
        try {
            isWatchClosed.await();
        } catch (InterruptedException e) {
            LOG.debug("Interrupted while waiting for the watch to close: {}", e.getMessage());
            Thread.currentThread().interrupt();
        }
        watch.close();
    }

    private static void parseMessageDispositionNotificationReportEntity(
            HttpMessage message, InputStream is, AS2SessionInputBuffer inBuffer, String boundary, String charsetName,
            String contentTransferEncoding)
            throws HttpException {
        DispositionNotificationMultipartReportEntity dispositionNotificationMultipartReportEntity = null;

        ObjectHelper.notNull(message, "message");
        ObjectHelper.notNull(inBuffer, "inBuffer");
        ObjectHelper.notNull(boundary, "boundary");
        ObjectHelper.notNull(charsetName, "charsetName");
        HttpEntity entity = ObjectHelper.notNull(EntityUtils.getMessageEntity(message), "message entity");

        if (entity instanceof DispositionNotificationMultipartReportEntity) {
             
            return;
        }

        Args.check(entity.isStreaming(), "Message entity can not be parsed: entity is not streaming");

        try {

            dispositionNotificationMultipartReportEntity
                    = parseMultipartReportEntityBody(inBuffer, is, boundary, charsetName, contentTransferEncoding);

            EntityUtils.setMessageEntity(message, dispositionNotificationMultipartReportEntity);

        } catch (Exception e) {
            throw new HttpException("Failed to parse entity content", e);
        }
    }

    protected void findLocations(Set<String> locations, ClassLoader classLoader) throws IOException {
        Enumeration<URL> resources = classLoader.getResources(LOCATION_PROPERTIES);
        while (resources.hasMoreElements()) {
            URL url = resources.nextElement();
            BufferedReader reader = IOHelper.buffered(new InputStreamReader(url.openStream(), UTF8));
            try {
                while (true) {
                    String line = reader.readLine();
                    if (line == null) {
                        break;
                    }
                    line = line.trim();
                    if (line.startsWith("#") || line.isEmpty()) {
                        continue;
                    }
                    locations.add(line);
                }
            } finally {
                IOHelper.close(reader, null, LOG);
            }
        }
    }

    public KeyPair getKey(String keyId) throws Exception {
        if (keyCache.containsKey(keyId)) {
            return keyCache.get(keyId);
        }

        Path keyFile = getKeyFile(keyId);
        if (!Files.exists(keyFile)) {
            throw new IllegalArgumentException("Key not found: " + keyId);
        }

        try (ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(Files.newInputStream(keyFile)))) {
            KeyPair keyPair = (KeyPair) ois.readObject();
            keyCache.put(keyId, keyPair);
            return keyPair;
        }
    }

    private ClientConfigurations initializeConfigurations(ImageRecognitionEndpoint endpoint) {
        ClientConfigurations clientConfigurations = new ClientConfigurations();

        clientConfigurations.setAccessKey(getAccessKey(endpoint));
        clientConfigurations.setSecretKey(getSecretKey(endpoint));
        clientConfigurations.setProjectId(getProjectId(endpoint));
        clientConfigurations.setEndpoint(getEndpoint(endpoint));

        clientConfigurations.setIgnoreSslVerification(endpoint.isIgnoreSslVerification());
        if (clientConfigurations.isIgnoreSslVerification()) {
            LOG.warn("SSL verification is ignored. This is unsafe in production environment");
        }
        if (!StringUtils.isEmpty(endpoint.getProxyHost())) {
            clientConfigurations.setProxyHost(endpoint.getProxyHost());
            clientConfigurations.setProxyPort(endpoint.getProxyPort());
            clientConfigurations.setProxyUser(endpoint.getProxyUser());
            clientConfigurations.setProxyPassword(endpoint.getProxyPassword());
        }
        return clientConfigurations;
    }

    private Expression createOrExpression(final Expression leftExp, final Expression rightExp) {
        return new Expression() {
            @Override
            public <T> T evaluate(Exchange exchange, Class<T> type) {
                Predicate predicate = ExpressionToPredicateAdapter.toPredicate(leftExp);
                predicate = PredicateBuilder.or(predicate, ExpressionToPredicateAdapter.toPredicate(rightExp));

                boolean answer = predicate.matches(exchange);
                return exchange.getContext().getTypeConverter().convertTo(type, answer);
            }

            @Override
            public String toString() {
                return left + " " + token.getText() + " " + right;
            }
        };
    }

    public void suspend() {
        lock.lock();
        try {
            if (status == SUSPENDED) {
                logger().trace("Service: {} already suspended", this);
                return;
            }
            if (status == SUSPENDING) {
                logger().trace("Service: {} already suspending", this);
                return;
            }
            status = SUSPENDING;
            logger().trace("Suspending service: {}", this);
            try (AutoCloseable ignored = doLifecycleChange()) {
                doSuspend();
                status = SUSPENDED;
                logger().trace("Suspended service: {}", this);
            } catch (Exception e) {
                logger().trace("Error while suspending service: {}", this, e);
                fail(e);
            }
        } finally {
            lock.unlock();
        }
    }

    public void initAnnotatedFields() {

        maxpos = 0;
        for (Class<?> cl : models) {
            List<Field> linkFields = new ArrayList<>();

            if (LOG.isDebugEnabled()) {
                LOG.debug("Class retrieved: {}", cl.getName());
            }

            for (Field field : cl.getDeclaredFields()) {
                DataField dataField = field.getAnnotation(DataField.class);
                if (dataField != null) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Position defined in the class: {}, position: {}, Field: {}",
                                cl.getName(), dataField.pos(), dataField);
                    }

                    if (dataField.required()) {
                        ++numberMandatoryFields;
                    } else {
                        ++numberOptionalFields;
                    }

                    int pos = dataField.pos();
                    if (annotatedFields.containsKey(pos)) {
                        Field f = annotatedFields.get(pos);
                        LOG.warn("Potentially invalid model: existing @DataField '{}' replaced by '{}'", f.getName(),
                                field.getName());
                    }
                    dataFields.put(pos, dataField);
                    annotatedFields.put(pos, field);
                    maxpos = Math.max(maxpos, pos);
                }

                Link linkField = field.getAnnotation(Link.class);

                if (linkField != null) {
                    if (LOG.isDebugEnabled()) {
                        LOG.debug("Class linked: {}, Field: {}", cl.getName(), field);
                    }
                    linkFields.add(field);
                }
            }

            if (!linkFields.isEmpty()) {
                annotatedLinkFields.put(cl.getName(), linkFields);
            }

            totalFields = numberMandatoryFields + numberOptionalFields;

            if (LOG.isDebugEnabled()) {
                LOG.debug("Number of optional fields: {}", numberOptionalFields);
                LOG.debug("Number of mandatory fields: {}", numberMandatoryFields);
                LOG.debug("Total: {}", totalFields);
            }
        }

        if (annotatedFields.size() < maxpos) {
            LOG.debug("Potentially incomplete model: some csv fields may not be mapped to @DataField members");
        }
    }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer target = (org.apache.camel.component.caffeine.load.CaffeineLoadCacheProducer) obj;
        switch (key) {
        case "as_map":
        case "AS_MAP": target.onAsMap(exchange.getMessage()); return null;
        case "cleanup":
        case "CLEANUP": target.onCleanUp(exchange.getMessage()); return null;
        case "get":
        case "GET": target.onGet(exchange.getMessage()); return null;
        case "get_all":
        case "GET_ALL": target.onGetAll(exchange.getMessage()); return null;
        case "invalidate":
        case "INVALIDATE": target.onInvalidate(exchange.getMessage()); return null;
        case "invalidate_all":
        case "INVALIDATE_ALL": target.onInvalidateAll(exchange.getMessage()); return null;
        case "put":
        case "PUT": target.onPut(exchange.getMessage()); return null;
        case "put_all":
        case "PUT_ALL": target.onPutAll(exchange.getMessage()); return null;
        default: return null;
        }
    }

    private void setupHealthCheckRegistry() {
        HealthCheckRegistry healthCheckRegistry = getBeanForType(HealthCheckRegistry.class);
        if (healthCheckRegistry != null) {
            healthCheckRegistry.setCamelContext(getContext());
            LOG.debug("Using HealthCheckRegistry: {}", healthCheckRegistry);
            getContext().getCamelContextExtension().addContextPlugin(HealthCheckRegistry.class, healthCheckRegistry);
        } else {
             
            healthCheckRegistry = HealthCheckRegistry.get(getContext());
            if (healthCheckRegistry != null) {
                healthCheckRegistry.setCamelContext(getContext());
            }
        }
        if (healthCheckRegistry != null) {
             
            Set<HealthCheckRepository> repositories = getContext().getRegistry().findByType(HealthCheckRepository.class);
            if (org.apache.camel.util.ObjectHelper.isNotEmpty(repositories)) {
                for (HealthCheckRepository repository : repositories) {
                    healthCheckRegistry.register(repository);
                }
            }
        }
    }

    protected String asTypeName(Class<?> classType) {
         
         
         
         
         
         
         
         

        String type;

        if (classType.isArray()) {
            type = classType.getComponentType().getName() + "[]";
        } else {
            type = classType.getName();
        }

        return type;
    }

        public AnnotationBuilder withDescription(JsonNode node) {
            if (node == null) {
                return this;
            }
            if (node.isMissingNode()) {
                return this;
            }
            if (!node.isTextual()) {
                return this;
            }

            return withDescription(node.asText());
        }

    public String resolveStaticUri(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        String topic = parseTopicName(entry.getUri());
        if (topic != null) {
            String originalTopic = parseTopicName(entry.getOriginalUri());
            if (!topic.equals(originalTopic)) {
                 
                String answer = entry.getUri();
                answer = StringHelper.replaceFirst(answer, topic, originalTopic);
                return answer;
            }
        }
        return null;
    }

    public GenericFileProcessStrategy<SftpRemoteFile> createGenericFileProcessStrategy(
            CamelContext context, Map<String, Object> params) {

         
         
        Expression moveExpression = (Expression) params.get("move");
        Expression moveFailedExpression = (Expression) params.get("moveFailed");
        Expression preMoveExpression = (Expression) params.get("preMove");
        boolean isNoop = params.get("noop") != null;
        boolean isDelete = params.get("delete") != null;
        boolean isMove = moveExpression != null || preMoveExpression != null || moveFailedExpression != null;

        if (isDelete) {
            GenericFileDeleteProcessStrategy<SftpRemoteFile> strategy = new GenericFileDeleteProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<SftpRemoteFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<SftpRemoteFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
            return strategy;
        } else if (isMove || isNoop) {
            GenericFileRenameProcessStrategy<SftpRemoteFile> strategy = new GenericFileRenameProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            if (!isNoop && moveExpression != null) {
                 
                GenericFileExpressionRenamer<SftpRemoteFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveExpression);
                strategy.setCommitRenamer(renamer);
            }
             
            if (moveFailedExpression != null) {
                GenericFileExpressionRenamer<SftpRemoteFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(moveFailedExpression);
                strategy.setFailureRenamer(renamer);
            }
             
            if (preMoveExpression != null) {
                GenericFileExpressionRenamer<SftpRemoteFile> renamer = new GenericFileExpressionRenamer<>();
                renamer.setExpression(preMoveExpression);
                strategy.setBeginRenamer(renamer);
            }
            return strategy;
        } else {
             
            GenericFileNoOpProcessStrategy<SftpRemoteFile> strategy = new GenericFileNoOpProcessStrategy<>();
            strategy.setExclusiveReadLockStrategy(getExclusiveReadLockStrategy(params));
            return strategy;
        }
    }

    private void modifyRecord(Exchange exchange) throws Exception {
        final Message in = exchange.getIn();
        final String tableName = getTableName(in);
        final String apiVersion = getApiVersion(in);
        final Class<?> requestModel = getRequestModel(in, tableName);
        final Class<?> responseModel = getResponseModel(in, tableName);
        final String sysId = getSysID(in);

        validateBody(in, requestModel);

        Response response = client.reset()
                .types(MediaType.APPLICATION_JSON_TYPE)
                .path("now")
                .path(apiVersion)
                .path("table")
                .path(tableName)
                .path(ObjectHelper.notNull(sysId, "sysId"))
                .query(ServiceNowParams.SYSPARM_DISPLAY_VALUE, in)
                .query(ServiceNowParams.SYSPARM_EXCLUDE_REFERENCE_LINK, in)
                .query(ServiceNowParams.SYSPARM_FIELDS, in)
                .query(ServiceNowParams.SYSPARM_INPUT_DISPLAY_VALUE, in)
                .query(ServiceNowParams.SYSPARM_SUPPRESS_AUTO_SYS_FIELD, in)
                .query(ServiceNowParams.SYSPARM_VIEW, in)
                .query(responseModel)
                .invoke(HttpMethod.PUT, in.getMandatoryBody());

        setBodyAndHeaders(exchange.getIn(), responseModel, response);
    }

    public void process(Exchange exchange) throws Exception {

        Map<String, Object> headers = exchange.getIn().getHeaders();

         
        Object oid = null;

        if (headers.containsKey(HazelcastConstants.OBJECT_ID)) {
            oid = headers.get(HazelcastConstants.OBJECT_ID);
        }

        final HazelcastOperation operation = lookupOperation(exchange);

        switch (operation) {
            case PUT:
                this.put(oid, exchange);
                break;

            case GET:
                this.get(oid, exchange);
                break;

            case DELETE:
                this.delete(oid);
                break;

            case CLEAR:
                this.clear();
                break;

            case CONTAINS_KEY:
                this.containsKey(oid, exchange);
                break;

            case CONTAINS_VALUE:
                this.containsValue(exchange);
                break;

            default:
                throw new IllegalArgumentException(
                        String.format("The value '%s' is not allowed for parameter '%s' on the MULTIMAP cache.", operation,
                                HazelcastConstants.OPERATION));
        }

         
        HazelcastComponentHelper.copyHeaders(exchange);
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        if (ObjectHelper.isEmpty(remaining)) {
            throw new IllegalArgumentException(
                    "Tool set and, optionally, the function, must be configured on the endpoint using syntax langchain4j-tools:toolId");
        }

         
        final String toolId = StringHelper.before(remaining, "/", remaining);
        final String tagList = parameters.get("tags").toString();
        if (ObjectHelper.isEmpty(tagList)) {
            throw new IllegalArgumentException("At least one tag must be specified");
        }

        LangChain4jToolsConfiguration langchain4jChatConfiguration = this.configuration.copy();

        Map<String, Object> toolParameters = PropertiesHelper.extractProperties(parameters, "parameter.");
        LangChain4jToolsEndpoint endpoint
                = new LangChain4jToolsEndpoint(uri, this, toolId, tagList, langchain4jChatConfiguration);
        endpoint.setParameters(toolParameters.entrySet().stream()
                .collect(Collectors.toMap(Map.Entry::getKey, e -> (String) e.getValue())));

        setProperties(endpoint, parameters);
        return endpoint;
    }

    public Expression createExpression(CamelContext camelContext, String expression) {
        ObjectHelper.notNull(left, "left node", this);
        ObjectHelper.notNull(right, "right node", this);

        final Expression leftExp = left.createExpression(camelContext, expression);
        final Expression rightExp = right.createExpression(camelContext, expression);

        if (operator == LogicalOperatorType.AND) {
            return createAndExpression(leftExp, rightExp);
        } else if (operator == LogicalOperatorType.OR) {
            return createOrExpression(leftExp, rightExp);
        }

        throw new SimpleParserException("Unknown logical operator " + operator, token.getIndex());
    }

    public Publisher<Exchange> from(String uri) {
        final String name = publishedUriToStream.computeIfAbsent(uri, camelUri -> {
            try {
                String uuid = context.getUuidGenerator().generateUuid();

                RouteBuilder.addRoutes(context, rb -> rb.from(camelUri).to("reactive-streams:" + uuid));

                return uuid;
            } catch (Exception e) {
                throw new IllegalStateException("Unable to create source reactive stream from direct URI: " + uri, e);
            }
        });

        return fromStream(name);
    }

    private <REQ, RES> void executeOperation(
            Exchange exchange,
            Class<REQ> requestClass,
            Function<REQ, RES> pojoExecutor,
            Supplier<RES> headerExecutor,
            String operationName,
            BiConsumer<RES, Message> responseProcessor)
            throws InvalidPayloadException {

        RES result;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (requestClass.isInstance(payload)) {
                try {
                    result = pojoExecutor.apply(requestClass.cast(payload));
                } catch (AwsServiceException ase) {
                    LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                    throw ase;
                }
                LOG.trace("{} request performing", operationName);
            } else {
                throw new IllegalArgumentException(
                        String.format("Expected body of type %s but was %s",
                                requestClass.getName(),
                                payload != null ? payload.getClass().getName() : "null"));
            }
        } else {
            try {
                result = headerExecutor.get();
            } catch (AwsServiceException ase) {
                LOG.trace("{} command returned the error code {}", operationName, ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
        Message message = getMessageForResponse(exchange);
        message.setBody(result);
        if (responseProcessor != null) {
            responseProcessor.accept(result, message);
        }
    }

    public static String afterLast(String text, String after) {
        if (text == null) {
            return null;
        }
        int pos = text.lastIndexOf(after);
        if (pos == -1) {
            return null;
        }
        return text.substring(pos + after.length());
    }

    public Processor createPreProcessor(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        if (exchange.getMessage().getHeader(KafkaConstants.OVERRIDE_TOPIC) != null) {
            return null;
        }

        final String topicName = parseTopicName(entry.getUri());
        return new Processor() {
            @Override
            public void process(Exchange exchange) throws Exception {
                exchange.getMessage().setHeader(KafkaConstants.OVERRIDE_TOPIC, topicName);
            }
        };
    }

    public MediaSizeName selectMediaSizeNameISO(String size) {
        if (size.equalsIgnoreCase("iso_a0")) {
            mediaSizeName = MediaSizeName.ISO_A0;
        } else if (size.equalsIgnoreCase("iso_a1")) {
            mediaSizeName = MediaSizeName.ISO_A1;
        } else if (size.equalsIgnoreCase("iso_a2")) {
            mediaSizeName = MediaSizeName.ISO_A2;
        } else if (size.equalsIgnoreCase("iso_a3")) {
            mediaSizeName = MediaSizeName.ISO_A3;
        } else if (size.equalsIgnoreCase("iso_a4")) {
            mediaSizeName = MediaSizeName.ISO_A4;
        } else if (size.equalsIgnoreCase("iso_a5")) {
            mediaSizeName = MediaSizeName.ISO_A5;
        } else if (size.equalsIgnoreCase("iso_a6")) {
            mediaSizeName = MediaSizeName.ISO_A6;
        } else if (size.equalsIgnoreCase("iso_a7")) {
            mediaSizeName = MediaSizeName.ISO_A7;
        } else if (size.equalsIgnoreCase("iso_a8")) {
            mediaSizeName = MediaSizeName.ISO_A8;
        } else if (size.equalsIgnoreCase("iso_a9")) {
            mediaSizeName = MediaSizeName.ISO_A9;
        } else if (size.equalsIgnoreCase("iso_a10")) {
            mediaSizeName = MediaSizeName.ISO_A10;
        } else if (size.equalsIgnoreCase("iso_b0")) {
            mediaSizeName = MediaSizeName.ISO_B0;
        } else if (size.equalsIgnoreCase("iso_b1")) {
            mediaSizeName = MediaSizeName.ISO_B1;
        } else if (size.equalsIgnoreCase("iso_b2")) {
            mediaSizeName = MediaSizeName.ISO_B2;
        } else if (size.equalsIgnoreCase("iso_b3")) {
            mediaSizeName = MediaSizeName.ISO_B3;
        } else if (size.equalsIgnoreCase("iso_b4")) {
            mediaSizeName = MediaSizeName.ISO_B4;
        } else if (size.equalsIgnoreCase("iso_b5")) {
            mediaSizeName = MediaSizeName.ISO_B5;
        } else if (size.equalsIgnoreCase("iso_b6")) {
            mediaSizeName = MediaSizeName.ISO_B6;
        } else if (size.equalsIgnoreCase("iso_b7")) {
            mediaSizeName = MediaSizeName.ISO_B7;
        } else if (size.equalsIgnoreCase("iso_b8")) {
            mediaSizeName = MediaSizeName.ISO_B8;
        } else if (size.equalsIgnoreCase("iso_b9")) {
            mediaSizeName = MediaSizeName.ISO_B9;
        } else if (size.equalsIgnoreCase("iso_b10")) {
            mediaSizeName = MediaSizeName.ISO_B10;
        } else if (size.equalsIgnoreCase("iso_c0")) {
            mediaSizeName = MediaSizeName.ISO_C0;
        } else if (size.equalsIgnoreCase("iso_c1")) {
            mediaSizeName = MediaSizeName.ISO_C1;
        } else if (size.equalsIgnoreCase("iso_c2")) {
            mediaSizeName = MediaSizeName.ISO_C2;
        } else if (size.equalsIgnoreCase("iso_c3")) {
            mediaSizeName = MediaSizeName.ISO_C3;
        } else if (size.equalsIgnoreCase("iso_c4")) {
            mediaSizeName = MediaSizeName.ISO_C4;
        } else if (size.equalsIgnoreCase("iso_c5")) {
            mediaSizeName = MediaSizeName.ISO_C5;
        } else if (size.equalsIgnoreCase("iso_c6")) {
            mediaSizeName = MediaSizeName.ISO_C6;
        }
        return mediaSizeName;
    }

    protected Endpoint createEndpoint(String uri, String remaining, Map<String, Object> parameters) throws Exception {
        if (ObjectHelper.isEmpty(remaining)) {
            throw new IllegalArgumentException(
                    "Tool set and, optionally, the function, must be configured on the endpoint using syntax langchain4j-tools:toolId");
        }

         
        final String toolId = StringHelper.before(remaining, "/", remaining);
        final String tagList = parameters.get("tags").toString();
        if (ObjectHelper.isEmpty(tagList)) {
            throw new IllegalArgumentException("At least one tag must be specified");
        }

        LangChain4jToolsConfiguration langchain4jChatConfiguration = this.configuration.copy();

        Map<String, Object> toolParameters = PropertiesHelper.extractProperties(parameters, "parameter.");
        LangChain4jToolsEndpoint endpoint
                = new LangChain4jToolsEndpoint(uri, this, toolId, tagList, langchain4jChatConfiguration);
        endpoint.setParameters(toolParameters.entrySet().stream()
                .collect(Collectors.toMap(Map.Entry::getKey, e -> (String) e.getValue())));

        setProperties(endpoint, parameters);
        return endpoint;
    }

    public void createQueryJob(
            QueryJob queryJob, Map<String, List<String>> headers, QueryJobResponseCallback callback) {
        final Request request = getRequest(HttpMethod.POST, queryJobUrl(null), headers);
        try {
            marshalRequest(queryJob, request);
        } catch (SalesforceException e) {
            callback.onResponse(null, Collections.emptyMap(), e);
            return;
        }
        doHttpRequestWithQueryJobResponse(callback, request);
    }

    private void createBuildGradle(Path settings, Path gradleBuild, Set<String> deps) throws Exception {
        String[] ids = gav.split(":");

        String context = readResourceTemplate("templates/spring-boot-build-gradle.tmpl");

        Properties prop = new CamelCaseOrderedProperties();
        RuntimeUtil.loadProperties(prop, settings);
        String repos = getMavenRepositories(settings, prop, camelSpringBootVersion);

        CamelCatalog catalog = CatalogLoader.loadSpringBootCatalog(repos, camelSpringBootVersion, download);
        String camelVersion = catalog.getLoadedVersion();

        context = context.replaceFirst("\\{\\{ \\.GroupId }}", ids[0]);
        context = context.replaceFirst("\\{\\{ \\.ArtifactId }}", ids[1]);
        context = context.replaceFirst("\\{\\{ \\.Version }}", ids[2]);
        context = context.replaceAll("\\{\\{ \\.SpringBootVersion }}", springBootVersion);
        context = context.replaceFirst("\\{\\{ \\.JavaVersion }}", javaVersion);
        context = context.replaceAll("\\{\\{ \\.CamelVersion }}", camelVersion);
        context = context.replaceFirst("\\{\\{ \\.CamelSpringBootVersion }}",
                Objects.requireNonNullElse(camelSpringBootVersion, camelVersion));

        if (repos == null || repos.isEmpty()) {
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", "");
        } else {
            StringBuilder sb = new StringBuilder();
            for (String repo : repos.split(",")) {
                sb.append("    maven {\n");
                sb.append("        url '").append(repo).append("'\n");
                if (repo.contains("snapshots")) {
                    sb.append("        mavenContent {\n");
                    sb.append("            snapshotsOnly()\n");
                    sb.append("        }\n");
                }
                sb.append("    }\n");
            }
            context = context.replaceFirst("\\{\\{ \\.MavenRepositories }}", sb.toString());
        }

        List<MavenGav> gavs = new ArrayList<>();
        for (String dep : deps) {
            MavenGav gav = parseMavenGav(dep);
            String gid = gav.getGroupId();
            String aid = gav.getArtifactId();

             
            if ("org.apache.camel".equals(gid)) {
                ArtifactModel<?> am = catalog.modelFromMavenGAV("org.apache.camel.springboot", aid + "-starter", null);
                if (am != null) {
                     
                    gav.setGroupId(am.getGroupId());
                    gav.setArtifactId(am.getArtifactId());
                    gav.setVersion(am.getVersion());
                } else {
                     
                    gav.setVersion(camelVersion);
                }
            }
            gavs.add(gav);
        }

         
        gavs.sort(mavenGavComparator());

        StringBuilder sb = new StringBuilder();
        for (MavenGav gav : gavs) {
            if ("lib".equals(gav.getPackaging())) {
                 
                sb.append("    implementation files('lib/").append(gav.getArtifactId())
                        .append("-").append(gav.getVersion()).append(".jar')\n");
            } else if ("camel-kamelets-utils".equals(gav.getArtifactId())) {
                 
                sb.append("    implementation ('").append(gav).append("') {\n");
                sb.append("        exclude group: 'org.apache.camel', module: '*'\n");
                sb.append("    }\n");
            } else {
                sb.append("    implementation '").append(gav).append("'\n");
            }
        }
        context = context.replaceFirst("\\{\\{ \\.CamelDependencies }}", sb.toString());

        IOHelper.writeText(context, Files.newOutputStream(gradleBuild));
    }

    public <T> void read(
            final Edm edm, final String resourcePath, final Map<String, String> queryParams,
            final Map<String, String> endpointHttpHeaders,
            final Olingo2ResponseHandler<T> responseHandler) {

        final UriInfoWithType uriInfo = parseUri(edm, resourcePath, queryParams);

        execute(new HttpGet(createUri(resourcePath, encodeQueryParams(queryParams))), getResourceContentType(uriInfo),
                endpointHttpHeaders,
                new AbstractFutureCallback<T>(responseHandler) {

                    @Override
                    public void onCompleted(HttpResponse result) throws IOException {
                        readContent(uriInfo, headersToMap(result.getAllHeaders()),
                                result.getEntity() != null ? result.getEntity().getContent() : null, responseHandler);
                    }

                });
    }

    public KinesisAsyncClient getAsyncClient(final Kinesis2Endpoint endpoint) {
        lock.lock();
        try {
            if (Objects.isNull(kinesisAsyncClient)) {
                kinesisAsyncClient = endpoint.getConfiguration().getAmazonKinesisAsyncClient() != null
                        ? endpoint.getConfiguration().getAmazonKinesisAsyncClient()
                        : KinesisClientFactory.getKinesisAsyncClient(endpoint.getConfiguration());
            }
            return kinesisAsyncClient;
        } finally {
            lock.unlock();
        }
    }

    private Function<Exchange, Object> updateEdge() {
        return exchange -> {
            try {
                ArangoEdgeCollection edgeCollection = calculateEdgeCollection();
                String key = (String) exchange.getMessage().getHeader(ARANGO_KEY);
                Object edgeDocument = exchange.getMessage().getMandatoryBody();
                return edgeCollection.updateEdge(key, edgeDocument);
            } catch (InvalidPayloadException e) {
                throw new RuntimeCamelException(INVALID_PAYLOAD_MESSAGE, e);
            }
        };
    }

    public static String resolveSpringBootVersionFromCamelSpringBoot(
            String repos, String camelSpringBootVersion, boolean download)
            throws Exception {
        DependencyDownloaderClassLoader cl = new DependencyDownloaderClassLoader(CatalogLoader.class.getClassLoader());
        MavenDependencyDownloader downloader = new MavenDependencyDownloader();
        downloader.setRepositories(repos);
        downloader.setClassLoader(cl);
        downloader.setDownload(download);
        try {
            downloader.start();

            List<MavenArtifact> artifacts
                    = downloader.downloadArtifacts("org.apache.camel.springboot", "camel-core-starter", camelSpringBootVersion,
                            true);
            for (MavenArtifact ma : artifacts) {
                String g = ma.getGav().getGroupId();
                String a = ma.getGav().getArtifactId();
                if ("org.springframework.boot".equals(g) && "spring-boot-starter".equals(a)) {
                    return ma.getGav().getVersion();
                }
            }
        } finally {
            downloader.stop();
            downloader.close();
        }

        return null;
    }

    public String summaryErrorMessage(boolean includeHeader, boolean ignoreDeprecated, boolean includeWarnings) {
        boolean ok = isSuccess();

         
        if (ok && !ignoreDeprecated) {
            ok = deprecated == null;
        }

        if (includeWarnings) {
            if (unknownComponent != null) {
                return "\tUnknown component: " + unknownComponent;
            }
        }

        if (ok) {
            return null;
        }

         
        Map<String, String> options = new LinkedHashMap<>();
        if (unknown != null) {
            for (String name : unknown) {
                if (unknownSuggestions != null && unknownSuggestions.containsKey(name)) {
                    String[] suggestions = unknownSuggestions.get(name);
                    if (suggestions != null && suggestions.length > 0) {
                        String str = Arrays.asList(suggestions).toString();
                        options.put(name, "Unknown option. Did you mean: " + str);
                    } else {
                        options.put(name, "Unknown option");
                    }
                } else {
                    options.put(name, "Unknown option");
                }
            }
        }
        if (required != null) {
            for (String name : required) {
                options.put(name, "Missing required option");
            }
        }
        if (deprecated != null) {
            for (String name : deprecated) {
                options.put(name, "Deprecated option");
            }
        }
        if (invalidEnum != null) {
            for (Map.Entry<String, String> entry : invalidEnum.entrySet()) {
                String name = entry.getKey();
                String[] choices = invalidEnumChoices.get(name);
                String defaultValue = defaultValues != null ? defaultValues.get(entry.getKey()) : null;
                String str = Arrays.asList(choices).toString();
                String msg = "Invalid enum value: " + entry.getValue() + ". Possible values: " + str;
                if (invalidEnumSuggestions != null) {
                    String[] suggestions = invalidEnumSuggestions.get(name);
                    if (suggestions != null && suggestions.length > 0) {
                        str = Arrays.asList(suggestions).toString();
                        msg += ". Did you mean: " + str;
                    }
                }
                if (defaultValue != null) {
                    msg += ". Default value: " + defaultValue;
                }

                options.put(entry.getKey(), msg);
            }
        }
        if (invalidReference != null) {
            for (Map.Entry<String, String> entry : invalidReference.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty reference value");
                } else if (!entry.getValue().startsWith("#")) {
                    options.put(entry.getKey(), "Invalid reference value: " + entry.getValue() + " must start with #");
                } else {
                    options.put(entry.getKey(), "Invalid reference value: " + entry.getValue());
                }
            }
        }
        if (invalidBoolean != null) {
            for (Map.Entry<String, String> entry : invalidBoolean.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty boolean value");
                } else {
                    options.put(entry.getKey(), "Invalid boolean value: " + entry.getValue());
                }
            }
        }
        if (invalidInteger != null) {
            for (Map.Entry<String, String> entry : invalidInteger.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty integer value");
                } else {
                    options.put(entry.getKey(), "Invalid integer value: " + entry.getValue());
                }
            }
        }
        if (invalidNumber != null) {
            for (Map.Entry<String, String> entry : invalidNumber.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty number value");
                } else {
                    options.put(entry.getKey(), "Invalid number value: " + entry.getValue());
                }
            }
        }
        if (invalidMap != null) {
            for (Map.Entry<String, String> entry : invalidMap.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty map key/value pair");
                } else {
                    options.put(entry.getKey(), "Invalid map key/value: " + entry.getValue());
                }
            }
        }
        if (invalidArray != null) {
            for (Map.Entry<String, String> entry : invalidArray.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty array index/value pair");
                } else {
                    options.put(entry.getKey(), "Invalid array index/value: " + entry.getValue());
                }
            }
        }

         
         
        int maxLen = 24;
        for (String key : options.keySet()) {
            maxLen = Math.max(maxLen, key.length());
        }
        String format = "%" + maxLen + "s    %s";

         
        StringBuilder sb = new StringBuilder();
        if (includeHeader) {
            sb.append("Configuration properties error\n");
            sb.append(
                    "---------------------------------------------------------------------------------------------------------------------------------------\n");
            sb.append("\n");
        }
        if (text != null) {
            sb.append("\t").append(text).append("\n");
        } else {
            sb.append("\n");
        }
        for (Map.Entry<String, String> option : options.entrySet()) {
            String out = String.format(format, shortKey(option.getKey()), option.getValue());
            sb.append("\n\t").append(out);
        }

        return sb.toString();
    }

    private ExecCreateCmd executeExecCreateRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Exec Create Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        ObjectHelper.notNull(containerId, MISSING_CONTAINER_ID);

        ExecCreateCmd execCreateCmd = client.execCreateCmd(containerId);

        Boolean attachStdIn
                = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_IN, configuration, message, Boolean.class);

        Boolean attachStdErr
                = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_ERR, configuration, message, Boolean.class);

        if (attachStdErr != null) {
            execCreateCmd.withAttachStderr(attachStdErr);
        }

        if (attachStdIn != null) {
            execCreateCmd.withAttachStdin(attachStdIn);
        }

        Boolean attachStdOut
                = DockerHelper.getProperty(DockerConstants.DOCKER_ATTACH_STD_OUT, configuration, message, Boolean.class);

        if (attachStdOut != null) {
            execCreateCmd.withAttachStdout(attachStdOut);
        }

        String[] cmd = DockerHelper.parseDelimitedStringHeader(DockerConstants.DOCKER_CMD, message);

        if (cmd != null) {
            execCreateCmd.withCmd(cmd);
        }

        Boolean tty = DockerHelper.getProperty(DockerConstants.DOCKER_TTY, configuration, message, Boolean.class);

        if (tty != null) {
            execCreateCmd.withTty(tty);
        }

        return execCreateCmd;

    }

    private HttpHandler getHandler(HttpServerExchange httpServerExchange, String method) {
        HttpHandler answer = null;

         
        if (method == null) {
            return null;
        }

        String path = httpServerExchange.getRequestURI();
        int idx = path.indexOf(token);
        if (idx > -1) {
            path = path.substring(idx + len);
        }
         
        path = pathAsKey(path);

        List<RestConsumerContextPathMatcher.ConsumerPath<UndertowConsumer>> paths = new ArrayList<>();
        for (final UndertowConsumer consumer : consumers) {
            paths.add(new RestConsumerPath(consumer));
        }

        RestConsumerContextPathMatcher.ConsumerPath<UndertowConsumer> best
                = RestConsumerContextPathMatcher.matchBestPath(method, path, paths);
        if (best != null) {
            answer = best.getConsumer();
        }

         
        List<UndertowConsumer> candidates = new ArrayList<>();
        if (answer == null) {
            for (final UndertowConsumer consumer : consumers) {

                String consumerPath = consumer.getEndpoint().getHttpURI().getPath();
                boolean matchOnUriPrefix = consumer.getEndpoint().isMatchOnUriPrefix();
                 
                if (RestConsumerContextPathMatcher.matchPath(path, consumerPath, matchOnUriPrefix)) {
                    candidates.add(consumer);
                }
            }
        }

         
        candidates = candidates.stream().filter(c -> matchRestMethod(method, c.getEndpoint().getHttpMethodRestrict()))
                .collect(Collectors.toList());
        if (candidates.size() == 1) {
            answer = candidates.get(0);
        }

        return answer;
    }

    public void deregister(ServiceDefinition definition) {
        if (definition.getId() == null) {
            throw new IllegalArgumentException("Service ID must be defined (definition=" + definition + ")");
        }
        if (definition.getName() == null) {
            throw new IllegalArgumentException("Service Name must be defined (definition=" + definition + ")");
        }

        try {
            for (ServiceInstance<MetaData> serviceInstance : serviceDiscovery.queryForInstances(definition.getName())) {
                if (Objects.equals(serviceInstance.getId(), definition.getId())) {
                    serviceDiscovery.unregisterService(serviceInstance);

                     
                    serviceList.remove(serviceInstance.getId());
                }
            }
        } catch (Exception e) {
            LOGGER.warn("{}", e.getMessage(), e);
        }
    }

    private static DataLakeServiceClient createDataLakeServiceClientWithClientSecret(
            final DataLakeConfiguration configuration) {
        ClientSecretCredential clientSecretCredential = configuration.getClientSecretCredential();
        if (clientSecretCredential == null) {
            LOG.trace("Using client id, client secret, tenant id to instantiate service client");
            clientSecretCredential = new ClientSecretCredentialBuilder()
                    .clientId(configuration.getClientId())
                    .clientSecret(configuration.getClientSecret())
                    .tenantId(configuration.getTenantId())
                    .build();
        } else {
            LOG.trace("Using configured client secret instance to instantiate service client");
        }

        return new DataLakeServiceClientBuilder()
                .credential(clientSecretCredential)
                .endpoint(buildAzureUri(configuration))
                .buildClient();
    }

    public Processor createProcessor() throws Exception {
        ObjectHelper.notNull(definition.getPattern(), "patterns", this);
        RemovePropertiesProcessor answer;
        if (definition.getExcludePatterns() != null) {
            answer = new RemovePropertiesProcessor(
                    parseString(definition.getPattern()), parseStrings(definition.getExcludePatterns()));
        } else if (definition.getExcludePattern() != null) {
            answer = new RemovePropertiesProcessor(
                    parseString(definition.getPattern()), parseStrings(new String[] { definition.getExcludePattern() }));
        } else {
            answer = new RemovePropertiesProcessor(parseString(definition.getPattern()), null);
        }
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    private boolean hasHeaderPatterns() {
        String[] parts = filter.split(",");
        for (String pattern : parts) {
            if (pattern.startsWith("--")) {
                continue;
            }
            if (pattern.startsWith("header:") || pattern.startsWith("+header:") || pattern.startsWith("-header:")) {
                return true;
            }
        }
        return false;
    }

    protected void doInit() throws Exception {
        super.doInit();

         
        if (getEndpoint().isSharedEntityManager()) {
            this.entityManager = SharedEntityManagerCreator.createSharedEntityManager(entityManagerFactory);
        } else {
            this.entityManager = entityManagerFactory.createEntityManager();
        }
        LOG.trace("Created EntityManager {} on {}", entityManager, this);
    }

    public Processor createProcessor() throws Exception {
        String key = parseString(definition.getName());
        Expression nameExpr;
        if (LanguageSupport.hasSimpleFunction(key)) {
            nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
        } else {
            nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
        }
        nameExpr.init(camelContext);

        String toKey = parseString(definition.getToName());
        Expression toNameExpr = null;
        if (toKey != null) {
            if (LanguageSupport.hasSimpleFunction(toKey)) {
                toNameExpr = camelContext.resolveLanguage("simple").createExpression(toKey);
            } else {
                toNameExpr = camelContext.resolveLanguage("constant").createExpression(toKey);
            }
            toNameExpr.init(camelContext);
        }

        Class<?> typeClass = parse(Class.class, or(definition.getTypeClass(), parseString(definition.getType())));
        String charset = validateCharset(parseString(definition.getCharset()));
        boolean mandatory = true;
        if (definition.getMandatory() != null) {
            mandatory = parseBoolean(definition.getMandatory(), true);
        }
        ConvertVariableProcessor answer
                = new ConvertVariableProcessor(key, nameExpr, toKey, toNameExpr, typeClass, charset, mandatory);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    private Volume messageToVolume(Message message) {
        Volume volume = message.getBody(Volume.class);
        if (volume == null) {
            Map headers = message.getHeaders();
            VolumeBuilder builder = Builders.volume();

            final String name = message.getHeader(OpenstackConstants.NAME, String.class);
            StringHelper.notEmpty(name, "Name ");
            builder.name(name);

            if (headers.containsKey(OpenstackConstants.DESCRIPTION)) {
                builder.description(message.getHeader(OpenstackConstants.DESCRIPTION, String.class));
            }

            if (headers.containsKey(CinderConstants.SIZE)) {
                builder.size(message.getHeader(CinderConstants.SIZE, Integer.class));
            }

            if (headers.containsKey(CinderConstants.VOLUME_TYPE)) {
                builder.volumeType(message.getHeader(CinderConstants.VOLUME_TYPE, String.class));
            }

            if (headers.containsKey(CinderConstants.IMAGE_REF)) {
                builder.imageRef(message.getHeader(CinderConstants.IMAGE_REF, String.class));
            }

            if (headers.containsKey(CinderConstants.SNAPSHOT_ID)) {
                builder.snapshot(message.getHeader(CinderConstants.SNAPSHOT_ID, String.class));
            }

            if (headers.containsKey(CinderConstants.IS_BOOTABLE)) {
                builder.bootable(message.getHeader(CinderConstants.IS_BOOTABLE, Boolean.class));
            }

            volume = builder.build();
        }

        return volume;
    }

            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                List<RecentReport> recentReports = null;
                if (response != null) {
                    try {
                        recentReports = unmarshalResponse(response, request, TypeReferences.RECENT_REPORT_LIST_TYPE);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(recentReports, headers, ex);
            }

    private KnativeConsumerFactory setUpConsumerFactory() throws Exception {
        if (consumerFactory == null) {
            this.consumerFactory = CamelContextHelper.lookup(getCamelContext(), protocol.name(), KnativeConsumerFactory.class);
            if (this.consumerFactory == null) {
                this.consumerFactory = getCamelContext()
                        .getCamelContextExtension()
                        .getBootstrapFactoryFinder(Knative.KNATIVE_TRANSPORT_RESOURCE_PATH)
                        .newInstance(protocol.name() + "-consumer", KnativeConsumerFactory.class)
                        .orElseThrow(() -> new IllegalArgumentException(
                                "Cannot create KnativeConsumerFactory. Make sure camel-knative-http JAR is on classpath."));
                if (configuration.getTransportOptions() != null) {
                    setProperties(consumerFactory, new HashMap<>(configuration.getTransportOptions()));
                }
                getCamelContext().addService(this.consumerFactory, true, true);
            }
            LOGGER.debug("Using Knative consumer factory: {} for protocol: {}", consumerFactory, protocol.name());
        }
        return consumerFactory;
    }

    private void doDelete(Exchange exchange, String tableName) throws KuduException {
        LOG.trace("Delete on table {}", tableName);
        KuduClient connection = endpoint.getKuduClient();
        KuduTable table = connection.openTable(tableName);

        Delete delete = table.newDelete();
        PartialRow row = delete.getRow();

        Map<?, ?> rows = exchange.getIn().getBody(Map.class);
        for (Map.Entry<?, ?> entry : rows.entrySet()) {
            final String colName = entry.getKey().toString();
            final Object value = entry.getValue();
            ColumnSchema column = table.getSchema().getColumn(colName);
            if (column != null && column.isKey()) {
                row.addObject(colName, value);
            }
        }

        connection.newSession().apply(delete);
    }

    public int processBatch(Queue<Object> exchanges) {
        final int total = exchanges.size();

        for (int index = 0; index < total && isBatchAllowed(); index++) {
             
            final Exchange exchange = ObjectHelper.cast(Exchange.class, exchanges.poll());

             
            exchange.setProperty(ExchangePropertyKey.BATCH_INDEX, index);
            exchange.setProperty(ExchangePropertyKey.BATCH_SIZE, total);
            exchange.setProperty(ExchangePropertyKey.BATCH_COMPLETE, index == total - 1);

             
            pendingExchanges = total - index - 1;

             
            exchange.getExchangeExtension().addOnCompletion(new Synchronization() {
                @Override
                public void onComplete(Exchange exchange) {
                    LOG.trace("Completed from processing all exchanges...");
                }

                @Override
                public void onFailure(Exchange exchange) {
                    processRollback(exchange);
                }
            });

             
            AsyncCallback cb = defaultConsumerCallback(exchange, true);
            getAsyncProcessor().process(exchange, cb);
        }
        return total;
    }

    public Exchange receive(Endpoint endpoint) {
        if (camelContext.isStopped()) {
            throw new RejectedExecutionException(CONTEXT_IS_STOPPED);
        }

        LOG.debug("<<<< {}", endpoint);
        PollingConsumer consumer = null;
        try {
            consumer = acquirePollingConsumer(endpoint);
            return consumer.receive();
        } finally {
            if (consumer != null) {
                releasePollingConsumer(endpoint, consumer);
            }
        }
    }

    protected void doStart() throws Exception {
         
         
        boolean startScheduler = isStartScheduler();
        setStartScheduler(false);
        try {
            super.doStart();
            if (endpoint.isAutoCreate() && hasStartingDirectory()) {
                LOG.debug("Auto creating directory: {}", endpointPath);
                try {
                    connectIfNecessary();
                    getOperations().buildDirectory(endpointPath, true);
                } catch (GenericFileOperationFailedException e) {
                     
                    LOG.warn("Error auto creating directory: {} due to {}. This exception is ignored.", endpointPath,
                            e.getMessage(),
                            e);
                }
            }
        } finally {
            if (startScheduler) {
                setStartScheduler(true);
                startScheduler();
            }
        }
    }

    public boolean process(final Exchange exchange, final AsyncCallback callback) {
        try {
             
            Runnable task = taskFactory.acquire(exchange, callback);

             
            if (exchange.isTransacted()) {
                reactiveExecutor.scheduleQueue(task);
            } else {
                reactiveExecutor.scheduleMain(task);
            }
            return false;
        } catch (Exception e) {
            exchange.setException(e);
            callback.done(true);
            return true;
        }
    }

private int jjMoveStringLiteralDfa5_0(long old0, long active0){
   if (((active0 &= old0)) == 0L)
      return jjStartNfa_0(3, old0);
   try { curChar = input_stream.readChar(); }
   catch(java.io.IOException e) {
      jjStopStringLiteralDfa_0(4, active0);
      return 5;
   }
   switch(curChar)
   {
      case 32:
         if ((active0 & 0x8L) != 0L)
            return jjStopAtPos(5, 3);
         break;
      default :
         break;
   }
   return jjStartNfa_0(4, active0);
}

    private AS2ApiCollection() {
        final Map<String, String> aliases = new HashMap<>();
        final Map<AS2ApiName, ApiMethodHelper<? extends ApiMethod>> apiHelpers = new EnumMap<>(AS2ApiName.class);
        final Map<Class<? extends ApiMethod>, AS2ApiName> apiMethods = new HashMap<>();

        List<String> nullableArgs;

        aliases.clear();
        nullableArgs = Arrays.asList("ediMessageTransferEncoding", "signingAlgorithm", "signingCertificateChain", "signingPrivateKey", "compressionAlgorithm", "dispositionNotificationTo", "signedReceiptMicAlgorithms", "encryptingAlgorithm", "encryptingCertificateChain", "attachedFileName", "receiptDeliveryOption", "ediMessageCharset", "userName", "password", "accessToken");
        apiHelpers.put(AS2ApiName.CLIENT, new ApiMethodHelper<>(AS2ClientManagerApiMethod.class, aliases, nullableArgs));
        apiMethods.put(AS2ClientManagerApiMethod.class, AS2ApiName.CLIENT);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(AS2ApiName.SERVER, new ApiMethodHelper<>(AS2ServerManagerApiMethod.class, aliases, nullableArgs));
        apiMethods.put(AS2ServerManagerApiMethod.class, AS2ApiName.SERVER);

        aliases.clear();
        nullableArgs = Arrays.asList();
        apiHelpers.put(AS2ApiName.RECEIPT, new ApiMethodHelper<>(AS2AsyncMDNServerManagerApiMethod.class, aliases, nullableArgs));
        apiMethods.put(AS2AsyncMDNServerManagerApiMethod.class, AS2ApiName.RECEIPT);

        setApiHelpers(apiHelpers);
        setApiMethods(apiMethods);
    }

    public static void setIn(Exchange exchange, Object payload) {
        if (payload instanceof DefaultExchangeHolder) {
            DefaultExchangeHolder.unmarshal(exchange, (DefaultExchangeHolder) payload);
        } else if (payload instanceof AddressedEnvelope) {
            @SuppressWarnings("unchecked")
            AddressedEnvelope<Object, InetSocketAddress> dp = (AddressedEnvelope<Object, InetSocketAddress>) payload;
             
            if (dp.content() instanceof DefaultExchangeHolder) {
                DefaultExchangeHolder.unmarshal(exchange, (DefaultExchangeHolder) dp.content());
            } else {
                 
                exchange.getIn().setBody(dp.content());
            }
             
            exchange.setProperty(NettyConstants.NETTY_REMOTE_ADDRESS, dp.sender());
             
            exchange.getIn().setHeader(NettyConstants.NETTY_REMOTE_ADDRESS, dp.sender());
        } else {
             
            exchange.getIn().setBody(payload);
        }
    }

    private void processGetBatch(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String jobId;
        BatchInfo batchBody = exchange.getIn().getBody(BatchInfo.class);
        String batchId;
        if (batchBody != null) {
            jobId = batchBody.getJobId();
            batchId = batchBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            batchId = getParameter(BATCH_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getBatch(jobId, batchId, determineHeaders(exchange), new BulkApiClient.BatchInfoResponseCallback() {
            @Override
            public void onResponse(BatchInfo batchInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, batchInfo, headers, ex, callback);
            }
        });
    }

    public static DocumentBuilderFactory createDocumentBuilderFactory() {
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);
        factory.setIgnoringElementContentWhitespace(true);
        factory.setIgnoringComments(true);
        try {
             
            factory.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, Boolean.TRUE);
        } catch (ParserConfigurationException e) {
        }
        try {
             
            factory.setFeature("http://xml.org/sax/features/external-general-entities", false);
        } catch (ParserConfigurationException e) {
        }
        try {
             
            factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
        } catch (ParserConfigurationException e) {
        }
         
        try {
            Class<?> smClass = ObjectHelper.loadClass("org.apache.xerces.util.SecurityManager");
            if (smClass != null) {
                Object sm = smClass.getDeclaredConstructor().newInstance();
                 
                factory.setAttribute("http://apache.org/xml/properties/security-manager", sm);
            }
        } catch (Exception e) {
        }
        return factory;
    }

    public FluentProducerTemplate withExchangeProperties(Map<String, Object> properties) {
        DefaultFluentProducerTemplate clone = checkCloned();

        if (clone.processorSupplier != null) {
            throw new IllegalArgumentException(
                    "Cannot use both withExchangeProperties and withProcessor with FluentProducerTemplate");
        }

        Map<String, Object> map = clone.exchangeProperties;
        if (map == null) {
            map = new LinkedHashMap<>();
            clone.exchangeProperties = map;
        }
        map.putAll(properties);
        return clone;
    }

    private boolean processAttribute(
            Class<?> originalClassType, Class<?> classElement,
            Field fieldElement, String fieldName,
            XmlAttribute attribute, Set<EipOptionModel> eipOptions,
            String prefix) {
        String name = attribute.name();
        if (Strings.isNullOrEmpty(name) || "##default".equals(name)) {
            name = fieldName;
        }

        Metadata metadata = fieldElement.getAnnotation(Metadata.class);

        name = prefix + name;
        Class<?> fieldTypeElement = fieldElement.getType();
        String fieldTypeName = getTypeName(GenericsUtil.resolveType(originalClassType, fieldElement));
        boolean isDuration = false;
        if (metadata != null && !Strings.isNullOrEmpty(metadata.javaType())) {
            String jt = metadata.javaType();
            if ("java.time.Duration".equals(jt)) {
                isDuration = true;
            } else {
                fieldTypeName = jt;
            }
        }

        String defaultValue = findDefaultValue(fieldElement, fieldTypeName);
        String docComment = findJavaDoc(fieldElement, fieldName, name, classElement, true);
        boolean required = attribute.required();
         
        required = findRequired(fieldElement, required);

         
        Set<String> enums;
        boolean isEnum;
        if (metadata != null && !Strings.isNullOrEmpty(metadata.enums())) {
             
            enums = new LinkedHashSet<>();
            isEnum = true;
            String[] values = metadata.enums().split(",");
            for (String val : values) {
                enums.add(val.trim());
            }
        } else {
            enums = new TreeSet<>();  
            isEnum = fieldTypeElement.isEnum();
            if (isEnum) {
                for (Object val : fieldTypeElement.getEnumConstants()) {
                    String str = val.toString();
                    enums.add(str);
                }
            }
        }

        boolean important = false;
        String displayName = null;
        if (metadata != null) {
            displayName = metadata.displayName();
            important = metadata.important();
        }
        boolean deprecated = fieldElement.getAnnotation(Deprecated.class) != null;
        String deprecationNote = null;
        if (metadata != null) {
            deprecationNote = metadata.deprecationNote();
        }
        String label = null;
        if (metadata != null) {
            label = metadata.label();
        }

        EipOptionModel ep = createOption(name, displayName, "attribute", fieldTypeName,
                required, defaultValue, label, docComment, deprecated, deprecationNote, isEnum, enums,
                null, false, isDuration, important);
        eipOptions.add(ep);

        return false;
    }

    public Producer createProducer() throws Exception {
        if (metricsType == MetricsType.COUNTER) {
            return new CounterProducer(this);
        } else if (metricsType == MetricsType.HISTOGRAM) {
            return new HistogramProducer(this);
        } else if (metricsType == MetricsType.METER) {
            return new MeterProducer(this);
        } else if (metricsType == MetricsType.TIMER) {
            return new TimerProducer(this);
        } else if (metricsType == MetricsType.GAUGE) {
            return new GaugeProducer(this);
        } else {
            throw new IllegalArgumentException("Metrics type " + metricsType + " is not supported");
        }
    }

    private ClientEntitySet filter(ClientEntitySet entitySet) {
        if (entitySet == null) {
            return new ClientEntitySetImpl();
        }

        List<ClientEntity> entities = entitySet.getEntities();

        if (entities.isEmpty()) {
            return entitySet;
        }

        List<ClientEntity> copyEntities = new ArrayList<>(entities);

        for (ClientEntity entity : copyEntities) {
            if (resultIndex.contains(entity.hashCode())) {
                entities.remove(entity);
            }
        }

        return entitySet;
    }

    public void search(String soslQuery, Map<String, List<String>> headers, ResponseCallback callback) {
        try {

            String encodedQuery = urlEncode(soslQuery);
            final Request get = getRequest(HttpMethod.GET, versionUrl() + "search/?q=" + encodedQuery, headers);

             
            setAccessToken(get);

            doHttpRequest(get, new DelegatingClientCallback(callback));

        } catch (UnsupportedEncodingException e) {
            String msg = "Unexpected error: " + e.getMessage();
            callback.onResponse(null, Collections.emptyMap(), new SalesforceException(msg, e));
        }
    }

    public static void configureSignatureAlgorithms(String names, AbstractFactoryManager factoryManager) {
        if (isBlank(names)) {
            return;
        }
        Set<BuiltinSignatures> builtIn = BuiltinSignatures.VALUES;
        Set<SignatureFactory> registered = BuiltinSignatures.getRegisteredExtensions();
        Set<SignatureFactory> allSignatureFactories = new HashSet<>();
        allSignatureFactories.addAll(builtIn);
        allSignatureFactories.addAll(registered);
        List<NamedFactory<Signature>> avail = (List) NamedFactory.setUpBuiltinFactories(false, allSignatureFactories);
        factoryManager.setSignatureFactories(filter(Signature.class, avail, names.split(",")));
    }

    private String getContent(Row r) {
        StringJoiner sj = new StringJoiner("   ");
        if (r.consumes != null || r.produces != null) {
            if (r.consumes != null) {
                sj.add("accept: " + r.consumes);
            }
            if (r.produces != null) {
                sj.add("produces: " + r.produces);
            }
        }
        if (sj.length() > 0) {
            return sj.toString();
        }
        return "";
    }

    private static void configureHttpClientPolicy(
            ServiceNowConfiguration configuration, WebClient client) {

        HTTPClientPolicy httpPolicy = configuration.getHttpClientPolicy();
        if (httpPolicy == null) {
            String host = configuration.getProxyHost();
            Integer port = configuration.getProxyPort();

            if (host != null && port != null) {
                httpPolicy = new HTTPClientPolicy();
                httpPolicy.setProxyServer(host);
                httpPolicy.setProxyServerPort(port);
            }
        }

        if (httpPolicy != null) {
            WebClient.getConfig(client).getHttpConduit().setClient(httpPolicy);
        }
    }

    public String getLastChosenProcessorId() {
        int idx = getProcessor().getLastChosenProcessorIndex();
        if (idx != -1) {
            LoadBalanceDefinition def = getDefinition();
            ProcessorDefinition<?> output = def.getOutputs().get(idx);
            if (output != null) {
                return output.getId();
            }
        }
        return null;
    }

    public QdrantClient getClient() {
        if (this.client == null) {
            lock.lock();
            try {
                if (this.client == null) {
                    this.client = this.configuration.getClient();
                    this.closeClient = false;

                    if (this.client == null) {
                        this.client = createClient();
                        this.closeClient = true;
                    }
                }
            } finally {
                lock.unlock();
            }
        }

        return this.client;
    }

    protected void processExchange(Exchange exchange) {
        Vertx vertx = getEndpoint().getVertx();
        vertx.executeBlocking(() -> {
            createUoW(exchange);
            getProcessor().process(exchange);
            return null;
        }, false)
                .onComplete(result -> {
                    try {
                        if (result.failed()) {
                            Throwable cause = result.cause();
                            getExceptionHandler().handleException(cause);
                        }
                    } finally {
                        doneUoW(exchange);
                        releaseExchange(exchange, false);
                    }
                });
    }

    protected void doListJobByLabel(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_JOB_LABELS, Map.class);
        JobList jobList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Get Job by labels require specify a labels set");
            throw new IllegalArgumentException("Get Job by labels require specify a labels set");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inAnyNamespace().withLabels(labels).list();
        } else {
            jobList = getEndpoint().getKubernetesClient().batch().v1().jobs().inNamespace(namespace).withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, jobList.getItems());
    }

    void ethNewFilter(Message message) throws IOException {
        DefaultBlockParameter fromBlock = toDefaultBlockParameter(
                message.getHeader(Web3jConstants.FROM_BLOCK, configuration::getFromBlock, String.class));
        DefaultBlockParameter toBlock
                = toDefaultBlockParameter(message.getHeader(Web3jConstants.TO_BLOCK, configuration::getToBlock, String.class));
        List<String> addresses = message.getHeader(Web3jConstants.ADDRESSES, configuration::getAddresses, List.class);
        List<String> topics = message.getHeader(Web3jConstants.TOPICS, configuration::getTopics, List.class);

        org.web3j.protocol.core.methods.request.EthFilter ethFilter
                = Web3jEndpoint.buildEthFilter(fromBlock, toBlock, addresses, topics);

        Request<?, EthFilter> request = web3j.ethNewFilter(ethFilter);
        setRequestId(message, request);
        EthFilter response = request.send();
        boolean hasError = checkForError(message, response);
        if (!hasError) {
            message.setBody(response.getFilterId());
        }
    }

    public Processor createPreProcessor(Exchange exchange, DynamicAwareEntry entry) throws Exception {
        if (exchange.getMessage().getHeader(JmsConstants.JMS_DESTINATION_NAME) != null) {
            return null;
        }

        final String destinationName = parseDestinationName(entry.getUri());
        return new Processor() {
            @Override
            public void process(Exchange exchange) {
                exchange.getMessage().setHeader(JmsConstants.JMS_DESTINATION_NAME, destinationName);
            }
        };
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumDb2Component) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumDb2Component) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumDb2Component) component).setConfiguration((org.apache.camel.component.debezium.db2.configuration.Db2ConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumDb2Component) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumDb2Component) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumDb2Component) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumDb2Component) component).setAutowiredEnabled((boolean) value); return true;
            case "cdcChangeTablesSchema": getOrCreateConfiguration((DebeziumDb2Component) component).setCdcChangeTablesSchema((java.lang.String) value); return true;
            case "cdcControlSchema": getOrCreateConfiguration((DebeziumDb2Component) component).setCdcControlSchema((java.lang.String) value); return true;
            case "columnExcludeList": getOrCreateConfiguration((DebeziumDb2Component) component).setColumnExcludeList((java.lang.String) value); return true;
            case "columnIncludeList": getOrCreateConfiguration((DebeziumDb2Component) component).setColumnIncludeList((java.lang.String) value); return true;
            case "columnPropagateSourceType": getOrCreateConfiguration((DebeziumDb2Component) component).setColumnPropagateSourceType((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumDb2Component) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumDb2Component) component).setConverters((java.lang.String) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumDb2Component) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumDb2Component) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseDbname": getOrCreateConfiguration((DebeziumDb2Component) component).setDatabaseDbname((java.lang.String) value); return true;
            case "databaseHostname": getOrCreateConfiguration((DebeziumDb2Component) component).setDatabaseHostname((java.lang.String) value); return true;
            case "databasePassword": getOrCreateConfiguration((DebeziumDb2Component) component).setDatabasePassword((java.lang.String) value); return true;
            case "databasePort": getOrCreateConfiguration((DebeziumDb2Component) component).setDatabasePort((int) value); return true;
            case "databaseUser": getOrCreateConfiguration((DebeziumDb2Component) component).setDatabaseUser((java.lang.String) value); return true;
            case "datatypePropagateSourceType": getOrCreateConfiguration((DebeziumDb2Component) component).setDatatypePropagateSourceType((java.lang.String) value); return true;
            case "db2Platform": getOrCreateConfiguration((DebeziumDb2Component) component).setDb2Platform((java.lang.String) value); return true;
            case "decimalHandlingMode": getOrCreateConfiguration((DebeziumDb2Component) component).setDecimalHandlingMode((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumDb2Component) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumDb2Component) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumDb2Component) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumDb2Component) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumDb2Component) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumDb2Component) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumDb2Component) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumDb2Component) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "includeSchemaChanges": getOrCreateConfiguration((DebeziumDb2Component) component).setIncludeSchemaChanges((boolean) value); return true;
            case "incrementalSnapshotChunkSize": getOrCreateConfiguration((DebeziumDb2Component) component).setIncrementalSnapshotChunkSize((int) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumDb2Component) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumDb2Component) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumDb2Component) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumDb2Component) component).setMaxQueueSizeInBytes((long) value); return true;
            case "messageKeyColumns": getOrCreateConfiguration((DebeziumDb2Component) component).setMessageKeyColumns((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumDb2Component) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumDb2Component) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumDb2Component) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumDb2Component) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumDb2Component) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumDb2Component) component).setProvideTransactionMetadata((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumDb2Component) component).setQueryFetchSize((int) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumDb2Component) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternal": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaHistoryInternal((java.lang.String) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaHistoryInternalSkipUnparseableDdl": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaHistoryInternalSkipUnparseableDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedDatabasesDdl": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaHistoryInternalStoreOnlyCapturedDatabasesDdl((boolean) value); return true;
            case "schemaHistoryInternalStoreOnlyCapturedTablesDdl": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaHistoryInternalStoreOnlyCapturedTablesDdl((boolean) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumDb2Component) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumDb2Component) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumDb2Component) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumDb2Component) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumDb2Component) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotLockTimeoutMs": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotLockTimeoutMs((long) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "snapshotSelectStatementOverrides": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotSelectStatementOverrides((java.lang.String) value); return true;
            case "snapshotTablesOrderByRowCount": getOrCreateConfiguration((DebeziumDb2Component) component).setSnapshotTablesOrderByRowCount((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumDb2Component) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumDb2Component) component).setStreamingDelayMs((long) value); return true;
            case "tableExcludeList": getOrCreateConfiguration((DebeziumDb2Component) component).setTableExcludeList((java.lang.String) value); return true;
            case "tableIgnoreBuiltin": getOrCreateConfiguration((DebeziumDb2Component) component).setTableIgnoreBuiltin((boolean) value); return true;
            case "tableIncludeList": getOrCreateConfiguration((DebeziumDb2Component) component).setTableIncludeList((java.lang.String) value); return true;
            case "timePrecisionMode": getOrCreateConfiguration((DebeziumDb2Component) component).setTimePrecisionMode((java.lang.String) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumDb2Component) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumDb2Component) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumDb2Component) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumDb2Component) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            default: return false;
            }
        }

    public Object invoke(Object obj, String key, Exchange exchange, AsyncCallback callback) throws Exception {
        org.apache.camel.component.consul.endpoint.ConsulAgentProducer target = (org.apache.camel.component.consul.endpoint.ConsulAgentProducer) obj;
        switch (key) {
        case "agent":
        case "AGENT": return target.invokeAgent(exchange.getMessage());
        case "checks":
        case "CHECKS": return target.invokeChecks(exchange.getMessage());
        case "deregister":
        case "DEREGISTER": target.invokeDeregister(exchange.getMessage()); return null;
        case "members":
        case "MEMBERS": return target.invokeMembers(exchange.getMessage());
        case "register":
        case "REGISTER": target.invokeRegister(exchange.getMessage()); return null;
        case "services":
        case "SERVICES": return target.invokeServices(exchange.getMessage());
        default: return null;
        }
    }

    private static GenericFileExclusiveReadLockStrategy<FTPFile> getExclusiveReadLockStrategy(Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<FTPFile> strategy
                = (GenericFileExclusiveReadLockStrategy<FTPFile>) params.get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<FTPFile> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                FtpChangedExclusiveReadLockStrategy readLockStrategy = new FtpChangedExclusiveReadLockStrategy();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            }
        }

        return null;
    }

    public String parseProperty(String key, String value, PropertiesLookup properties) {
        String answer = parser.parseProperty(key, value, properties);
        if (answer != null) {
            answer = springResolvePlaceholders(answer, properties);
        } else {
            answer = springResolvePlaceholders(value, properties);
        }
        return answer;
    }

    public ActiveMQQueueEndpoint(String uri, JmsComponent component, String destination,
                                 JmsConfiguration configuration, QueueBrowseStrategy queueBrowseStrategy) {
        super(uri, component, destination, false, configuration);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    private Consumer<ThroughputResponse> setThroughputResponseOnExchange(final Exchange exchange) {
        return response -> {
            if (ObjectHelper.isNotEmpty(response.getProperties())) {
                setMessageHeader(exchange, CosmosDbConstants.AUTOSCALE_MAX_THROUGHPUT,
                        response.getProperties().getAutoscaleMaxThroughput());
                setMessageHeader(exchange, CosmosDbConstants.MANUAL_THROUGHPUT, response.getProperties().getManualThroughput());
                setMessageHeader(exchange, CosmosDbConstants.E_TAG, response.getProperties().getETag());
                setMessageHeader(exchange, CosmosDbConstants.TIMESTAMP, response.getProperties().getTimestamp());
            }
            setCommonResponseOnExchange(exchange, response);
        };
    }

        public void parse(String systemId) throws IOException, SAXException {
            lock.lock();
            try {
                checkValid();
                try {
                    xmlReader.parse(systemId);
                } finally {
                    release();
                }
            } finally {
                lock.unlock();
            }
        }

    private String createCodeHeader(final String function) {
         
        String remainder = ifStartsWithReturnRemainder("headerAsIndex(", function);
        if (remainder != null) {
            String keyTypeAndIndex = StringHelper.before(remainder, ")");
            if (keyTypeAndIndex == null) {
                throw new SimpleParserException(
                        "Valid syntax: ${headerAsIndex(key, type, index)} was: " + function, token.getIndex());
            }
            String[] parts = keyTypeAndIndex.split(",");
            if (parts.length != 3) {
                throw new SimpleParserException(
                        "Valid syntax: ${headerAsIndex(key, type, index)} was: " + function, token.getIndex());
            }
            String key = parts[0];
            String type = parts[1];
            String index = parts[2];
            if (ObjectHelper.isEmpty(key) || ObjectHelper.isEmpty(type) || ObjectHelper.isEmpty(index)) {
                throw new SimpleParserException(
                        "Valid syntax: ${headerAsIndex(key, type, index)} was: " + function, token.getIndex());
            }
            key = StringHelper.removeQuotes(key);
            key = key.trim();
            type = appendClass(type);
            type = type.replace('$', '.');
            type = type.trim();
            index = StringHelper.removeQuotes(index);
            index = index.trim();
            remainder = StringHelper.after(remainder, ")");
            if (ObjectHelper.isNotEmpty(remainder)) {
                boolean invalid = OgnlHelper.isInvalidValidOgnlExpression(remainder);
                if (invalid) {
                    throw new SimpleParserException(
                            "Valid syntax: ${headerAsIndex(key, type, index).OGNL} was: " + function, token.getIndex());
                }
                return "headerAsIndex(message, " + type + ", \"" + key + "\", \"" + index + "\")"
                       + ognlCodeMethods(remainder, type);
            } else {
                return "headerAsIndex(message, " + type + ", \"" + key + "\", \"" + index + "\")";
            }
        }

         
        remainder = ifStartsWithReturnRemainder("headerAs(", function);
        if (remainder != null) {
            String keyAndType = StringHelper.before(remainder, ")");
            if (keyAndType == null) {
                throw new SimpleParserException("Valid syntax: ${headerAs(key, type)} was: " + function, token.getIndex());
            }

            String key = StringHelper.before(keyAndType, ",");
            String type = StringHelper.after(keyAndType, ",");
            remainder = StringHelper.after(remainder, ")");
            if (ObjectHelper.isEmpty(key) || ObjectHelper.isEmpty(type)) {
                throw new SimpleParserException("Valid syntax: ${headerAs(key, type)} was: " + function, token.getIndex());
            }
            key = StringHelper.removeQuotes(key);
            key = key.trim();
            type = appendClass(type);
            type = type.replace('$', '.');
            type = type.trim();
            return "headerAs(message, \"" + key + "\", " + type + ")" + ognlCodeMethods(remainder, type);
        }

         
        if ("in.headers".equals(function) || "headers".equals(function)) {
            return "message.getHeaders()";
        } else if ("headers.size".equals(function) || "headers.size()".equals(function)
                || "headers.length".equals(function) || "headers.length()".equals(function)) {
            return "message.getHeaders().size()";
        }

         
        remainder = parseInHeader(function);
        if (remainder != null) {
             
            if (remainder.startsWith(".") || remainder.startsWith(":") || remainder.startsWith("?")) {
                remainder = remainder.substring(1);
            }
             
            if (remainder.startsWith("[") && remainder.endsWith("]")) {
                remainder = remainder.substring(1, remainder.length() - 1);
            }
             
            String key = StringHelper.removeLeadingAndEndingQuotes(remainder);
            key = key.trim();

             
            boolean invalid = OgnlHelper.isInvalidValidOgnlExpression(key);
            if (invalid) {
                throw new SimpleParserException("Valid syntax: ${header.name[key]} was: " + function, token.getIndex());
            }

             
             
            boolean index = false;
            List<String> parts = splitOgnl(key);
            if (!parts.isEmpty()) {
                String s = parts.get(0);
                int pos = s.indexOf('[');
                if (pos != -1) {
                    index = true;
                     
                    String before = s.substring(0, pos);
                    String after = s.substring(pos);
                    parts.set(0, before);
                    parts.add(1, after);
                }
            }
            if (index) {
                 
                 
                String func = "headerAsIndex(\"" + parts.get(0) + "\", Object.class, \"" + parts.get(1) + "\")";
                if (parts.size() > 2) {
                    String last = String.join("", parts.subList(2, parts.size()));
                    if (!last.isEmpty()) {
                        func += "." + last;
                    }
                }
                return createCodeHeader(func);
            } else if (OgnlHelper.isValidOgnlExpression(key)) {
                 
                throw new SimpleParserException("Valid syntax: ${headerAs(key, type).OGNL} was: " + function, token.getIndex());
            } else {
                 
                return "header(message, \"" + key + "\")";
            }
        }

        return null;
    }

    private void setupHealthCheckRegistry() {
        HealthCheckRegistry healthCheckRegistry = getBeanForType(HealthCheckRegistry.class);
        if (healthCheckRegistry != null) {
            healthCheckRegistry.setCamelContext(getContext());
            LOG.debug("Using HealthCheckRegistry: {}", healthCheckRegistry);
            getContext().getCamelContextExtension().addContextPlugin(HealthCheckRegistry.class, healthCheckRegistry);
        } else {
             
            healthCheckRegistry = HealthCheckRegistry.get(getContext());
            if (healthCheckRegistry != null) {
                healthCheckRegistry.setCamelContext(getContext());
            }
        }
        if (healthCheckRegistry != null) {
             
            Set<HealthCheckRepository> repositories = getContext().getRegistry().findByType(HealthCheckRepository.class);
            if (org.apache.camel.util.ObjectHelper.isNotEmpty(repositories)) {
                for (HealthCheckRepository repository : repositories) {
                    healthCheckRegistry.register(repository);
                }
            }
        }
    }

    public Map<String, String> getServiceMetadata() {
        HashMap<String, String> metadata = new HashMap<>();
        if (configuration.getQueueArn() != null) {
            metadata.put("queueArn", configuration.getQueueArn());
        }
        if (configuration.getTopicArn() != null) {
            metadata.put("topicArn", configuration.getTopicArn());
        }
        return metadata;
    }

    public int forceCompletionOfGroup(String key) {
         
        int total = 0;

        lock.lock();
        try {
            Exchange exchange = aggregationRepository.get(camelContext, key);
            if (exchange != null) {
                total = 1;
                LOG.trace("Force completion triggered for correlation key: {}", key);
                 
                exchange.setProperty(ExchangePropertyKey.AGGREGATED_COMPLETED_BY, COMPLETED_BY_FORCE);
                Exchange answer = onCompletion(key, exchange, exchange, false, false);
                if (answer != null) {
                    onSubmitCompletion(key, answer);
                }
            }
        } finally {
            lock.unlock();
        }
        LOG.trace("Completed force completion of group {}", key);

        if (total > 0) {
            LOG.debug("Forcing completion of group {} with {} exchanges", key, total);
        }
        return total;
    }

    protected void doListConfigMapsByLabels(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_CONFIGMAPS_LABELS, Map.class);
        ConfigMapList configMapsList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Listing ConfigMaps by labels requires specifying labels");
            throw new IllegalArgumentException("Listing ConfigMaps by labels requires specifying labels");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            configMapsList = getEndpoint().getKubernetesClient().configMaps().inAnyNamespace().withLabels(labels).list();
        } else {
            configMapsList = getEndpoint().getKubernetesClient().configMaps().inNamespace(namespace).withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, configMapsList.getItems());
    }

    public RoutePolicy createRoutePolicy(CamelContext camelContext, String routeId, NamedNode routeDefinition) {
        MicrometerRoutePolicy answer = new MicrometerRoutePolicy(this);
        answer.setMeterRegistry(getMeterRegistry());
        answer.setPrettyPrint(isPrettyPrint());
        answer.setSkipCamelInfo(isSkipCamelInfo());
        answer.setDurationUnit(getDurationUnit());
        answer.setNamingStrategy(getNamingStrategy());
        answer.setConfiguration(getPolicyConfiguration());
        return answer;
    }

    public Object doUnmarshal(Exchange exchange, InputStream stream, Object rootObject) throws IOException {
        if (rootObject.getClass() != Envelope.class) {
            throw new RuntimeCamelException("Expected Soap Envelope but got " + rootObject.getClass());
        }
        Envelope envelope = (Envelope) rootObject;

        Header header = envelope.getHeader();
        if (header != null) {
            List<Object> returnHeaders;
            List<Object> anyHeaderElements = envelope.getHeader().getAny();
            if (null != anyHeaderElements && !(getDataFormat().isIgnoreUnmarshalledHeaders())) {
                if (getDataFormat().isIgnoreJAXBElement()) {
                    returnHeaders = new ArrayList<>();
                    for (Object headerEl : anyHeaderElements) {
                        returnHeaders.add(JAXBIntrospector.getValue(headerEl));
                    }
                } else {
                    returnHeaders = anyHeaderElements;
                }
                exchange.getOut().setHeader(SoapDataFormat.SOAP_UNMARSHALLED_HEADER_LIST, returnHeaders);
            }
        }

        List<Object> anyElement = envelope.getBody().getAny();
        if (anyElement.isEmpty()) {
             
            return null;

        }
        Object payloadEl = anyElement.get(0);
        Object payload = JAXBIntrospector.getValue(payloadEl);
        if (payload instanceof Fault) {
            String soapAction = exchange.getProperty(SoapConstants.SOAP_ACTION, String.class);
            Exception exception = createExceptionFromFault(soapAction, (Fault) payload);
            exchange.setException(exception);
            return null;
        } else {
            return getDataFormat().isIgnoreJAXBElement() ? payload : payloadEl;
        }
    }

    private static void resolveGithubAsRawFiles(
            String url, String wildcard, StringJoiner routes, StringJoiner kamelets, StringJoiner properties, StringJoiner all)
            throws Exception {

         
        HttpClient hc = HttpClient.newHttpClient();
        HttpResponse<String> res = hc.send(HttpRequest.newBuilder(new URI(url)).timeout(Duration.ofSeconds(20)).build(),
                HttpResponse.BodyHandlers.ofString());

        if (res.statusCode() == 200) {
            ObjectMapper mapper = new ObjectMapper();
            JsonNode root = mapper.readTree(res.body());
            for (JsonNode c : root) {
                String name = c.get("name").asText();
                String ext = FileUtil.onlyExt(name, false);
                boolean match = wildcard == null || AntPathMatcher.INSTANCE.match(wildcard, name, false);
                if (match) {
                    if (kamelets != null && "kamelet.yaml".equalsIgnoreCase(ext)) {
                        String htmlUrl = c.get("html_url").asText();
                        String u = asGithubSingleUrl(htmlUrl);
                        kamelets.add(u);
                    } else if (properties != null && "properties".equalsIgnoreCase(ext)) {
                        String htmlUrl = c.get("html_url").asText();
                        String u = asGithubSingleUrl(htmlUrl);
                        properties.add(u);
                    } else if (routes != null) {
                        if ("java".equalsIgnoreCase(ext) || "xml".equalsIgnoreCase(ext)
                                || "yaml".equalsIgnoreCase(ext) || "camel.yaml".equalsIgnoreCase(ext)) {
                            String htmlUrl = c.get("html_url").asText();
                            String u = asGithubSingleUrl(htmlUrl);
                            routes.add(u);
                        }
                    } else if (all != null) {
                        String htmlUrl = c.get("html_url").asText();
                        String u = asGithubSingleUrl(htmlUrl);
                        all.add(u);
                    }
                }
            }
        }
    }

    public DocFlavor forMimeTypeBasic(String flavor, String mimeType) {
        if (mimeType.equalsIgnoreCase("TEXT_HTML_UTF_16BE")) {
            if (flavor.equalsIgnoreCase("DocFlavor.CHAR_ARRAY")) {
                d = DocFlavor.CHAR_ARRAY.TEXT_HTML;
            } else if (flavor.equalsIgnoreCase("DocFlavor.READER")) {
                d = DocFlavor.READER.TEXT_HTML;
            } else if (flavor.equalsIgnoreCase("DocFlavor.STRING")) {
                d = DocFlavor.STRING.TEXT_HTML;
            }
        } else {
            if (flavor.equalsIgnoreCase("DocFlavor.CHAR_ARRAY")) {
                d = DocFlavor.CHAR_ARRAY.TEXT_PLAIN;
            } else if (flavor.equalsIgnoreCase("DocFlavor.READER")) {
                d = DocFlavor.READER.TEXT_PLAIN;
            } else if (flavor.equalsIgnoreCase("DocFlavor.STRING")) {
                d = DocFlavor.STRING.TEXT_PLAIN;
            }
        }

        return d;
    }

    List<Long> findPids(String name) {
        List<Long> pids = new ArrayList<>();

         
        if (name.matches("\\d+")) {
            return List.of(Long.parseLong(name));
        } else {
            if (name.endsWith("!")) {
                 
                name = name.substring(0, name.length() - 1);
            } else if (!name.endsWith("*")) {
                 
                name = name + "*";
            }
        }

        final long cur = ProcessHandle.current().pid();
        final String pattern = name;
        ProcessHandle.allProcesses()
                .filter(ph -> ph.pid() != cur)
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        String pName = ProcessHelper.extractName(root, ph);
                         
                        pName = FileUtil.onlyName(pName);
                        if (pName != null && !pName.isEmpty() && PatternHelper.matchPattern(pName, pattern)) {
                            pids.add(ph.pid());
                        } else {
                             
                            JsonObject context = (JsonObject) root.get("context");
                            if (context != null) {
                                pName = context.getString("name");
                                if ("CamelJBang".equals(pName)) {
                                    pName = null;
                                }
                                if (pName != null && !pName.isEmpty() && PatternHelper.matchPattern(pName, pattern)) {
                                    pids.add(ph.pid());
                                }
                            }
                        }
                    }
                });

        return pids;
    }

    public void onExchangeDone(Exchange exchange) {
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(registerTemplates, registerKamelets);
            if (level <= 1) {
                super.onExchangeDone(exchange);
            }
        } else {
            super.onExchangeDone(exchange);
        }
    }

    public static String nodeValue(final int namespace, final String node) {
        Objects.requireNonNull(namespace);
        Objects.requireNonNull(node);

        final StringBuilder builder = new StringBuilder("RAW(");
        appendNamespace(builder, namespace);
        builder.append(';');
        appendNodeId(builder, node);
        builder.append(')');
        return builder.toString();
    }

    public void completedExchange(Exchange exchange, long time) {
        if (counter1.isStatisticsEnabled()) {
            counter1.completedExchange(exchange, time);
        }
        if (counter2.isStatisticsEnabled()) {
            counter2.completedExchange(exchange, time);
        }
        if (counter3 != null && counter3.isStatisticsEnabled()) {
            counter3.completedExchange(exchange, time);
        }
    }

    public ManagedStepMBean getManagedStep(String id) {
         
        if (getManagementStrategy().getManagementAgent() == null) {
            return null;
        }

        Processor processor = camelContext.getProcessor(id);
        ProcessorDefinition<?> def
                = camelContext.getCamelContextExtension().getContextPlugin(Model.class).getProcessorDefinition(id);

         
        if (def != null) {
            try {
                ObjectName on = getManagementStrategy().getManagementObjectNameStrategy()
                        .getObjectNameForStep(camelContext, processor, def);
                return getManagementStrategy().getManagementAgent().newProxyClient(on, ManagedStepMBean.class);
            } catch (MalformedObjectNameException e) {
                throw RuntimeCamelException.wrapRuntimeCamelException(e);
            }
        }

        return null;
    }

    public void configureProperties(Map<String, Object> options) {
         
        Map<String, Object> query = new CaseInsensitiveMap();
        Map<String, Object> known = new CaseInsensitiveMap();
        options.forEach((k, v) -> {
            if (k.startsWith("$")) {
                query.put(k, v);
            } else {
                known.put(k, v);
            }
        });
        options.keySet().removeIf(known::containsKey);

         
        PropertyConfigurer configurer = getComponent().getEndpointPropertyConfigurer();
        if (configurer instanceof ExtendedPropertyConfigurerGetter) {
            ExtendedPropertyConfigurerGetter getter = (ExtendedPropertyConfigurerGetter) configurer;
            for (String name : getter.getAllOptions(this).keySet()) {
                if (known.containsKey(name)) {
                    Object value = known.get(name);
                    boolean hit = configurer.configure(getCamelContext(), this, name, value, true);
                    if (hit) {
                        known.remove(name);
                    }
                }
            }
        }
         
        configurer = PluginHelper.getConfigurerResolver(getCamelContext())
                .resolvePropertyConfigurer(configuration.getClass().getName(), getCamelContext());
        if (configurer != null) {
            PropertyBindingSupport.build()
                    .withConfigurer(configurer)
                    .withIgnoreCase(true)
                    .withTarget(configuration)
                    .withCamelContext(getCamelContext())
                    .withProperties(known)
                    .withRemoveParameters(true)
                    .bind();
        }
        super.configureProperties(known);
        if (!known.isEmpty()) {
             
            query.putAll(known);
        }
         
        options.keySet().removeIf(query::containsKey);
         
        parseQueryParams(query);
         
        options.putAll(query);
    }

    private void configureTimeoutExecutorService(ResilienceProcessor processor, Resilience4jConfigurationCommon config) {
        if (!parseBoolean(config.getTimeoutEnabled(), false)) {
            return;
        }

        if (config.getTimeoutExecutorService() != null) {
            String ref = config.getTimeoutExecutorService();
            boolean shutdownThreadPool = false;
            ExecutorService executorService = lookupByNameAndType(ref, ExecutorService.class);
            if (executorService == null) {
                executorService = lookupExecutorServiceRef("CircuitBreaker", definition, ref);
                shutdownThreadPool = true;
            }
            processor.setExecutorService(executorService);
            processor.setShutdownExecutorService(shutdownThreadPool);
        }
    }

    public Consumer createConsumer(Processor processor) throws Exception {
        Consumer consumer;
        if (getConfiguration().isConsumeAsClient()) {
            consumer = new VertxWebsocketClientConsumer(this, processor);
        } else {
            consumer = new VertxWebsocketConsumer(this, processor);
        }
        configureConsumer(consumer);
        return consumer;
    }

    private void get(Exchange exchange) throws Exception {
        final Message in = exchange.getMessage();

        String collectionName = getCollectionName(in);
        Collection collection = this.client.getCollection(collectionName, embeddingFunction);

        List<String> ids = in.getHeader(ChromaHeaders.IDS, List.class);
        Map<String, String> where = in.getHeader(ChromaHeaders.WHERE, Map.class);
        Map<String, Object> whereDocument = in.getHeader(ChromaHeaders.WHERE_DOCUMENT, Map.class);

        Collection.GetResult result = collection.get(ids, where, whereDocument);

        in.setBody(result);
        in.setHeader(ChromaHeaders.OPERATION_STATUS, "SUCCESS");
    }

    protected void doStop() throws Exception {
        super.doStop();

        if (stopClient && client != null && client.isConnected()) {
            String topic = getEndpoint().getTopic();
             
            if (getEndpoint().getConfiguration().isCleanSession()) {
                LOG.debug("Unsubscribing client: {} from topic: {}", clientId, topic);
                client.unsubscribe(topic);
            } else {
                LOG.debug("Client: {} is durable so will not unsubscribe from topic: {}", clientId, topic);
            }
            LOG.debug("Disconnecting client: {} from broker: {}", clientId, getEndpoint().getConfiguration().getBrokerUrl());
            client.disconnect();
        }
        client = null;
    }

    protected void processStrategyRollback(
            GenericFileProcessStrategy<T> processStrategy, Exchange exchange, GenericFile<T> file) {

        if (LOG.isWarnEnabled()) {
            LOG.warn("Rollback file strategy: {} for file: {}", processStrategy, file);
        }

        if (Boolean.TRUE.equals(endpoint.isIdempotent())) {
             
             
            String key = absoluteFileName;
            if (endpoint.getIdempotentKey() != null) {
                Exchange dummy = GenericFileHelper.createDummy(endpoint, exchange, () -> file);
                key = endpoint.getIdempotentKey().evaluate(dummy, String.class);
            }
            if (key != null) {
                endpoint.getIdempotentRepository().remove(key);
            }
        }

         
         
         
        if (endpoint.getMoveFailed() != null) {
            handleDoneFile(exchange);
        }

        try {
            processStrategy.rollback(operations, endpoint, exchange, file);
        } catch (Exception e) {
            handleException("Error during rollback", exchange, e);
        }
    }

    private ImageClient initializeSdkClient(ImageRecognitionEndpoint endpoint, ClientConfigurations clientConfigurations) {
        if (endpoint.getImageClient() != null) {
            LOG.info(
                    "Instance of ImageClient was set on the endpoint. Skipping creation of ImageClient from endpoint parameters");
            this.imageClient = endpoint.getImageClient();
            return endpoint.getImageClient();
        }
        HttpConfig httpConfig
                = HttpConfig.getDefaultHttpConfig().withIgnoreSSLVerification(clientConfigurations.isIgnoreSslVerification());
        if (!StringUtils.isEmpty(clientConfigurations.getProxyHost())) {
            httpConfig.setProxyHost(clientConfigurations.getProxyHost());
            httpConfig.setProxyPort(clientConfigurations.getProxyPort());
            if (!StringUtils.isEmpty(clientConfigurations.getProxyUser())) {
                httpConfig.setProxyUsername(clientConfigurations.getProxyUser());
                httpConfig.setProxyPassword(clientConfigurations.getProxyPassword());
            }
        }

        BasicCredentials credentials = new BasicCredentials().withAk(clientConfigurations.getAccessKey())
                .withSk(clientConfigurations.getSecretKey())
                .withProjectId(clientConfigurations.getProjectId());

        imageClient = ImageClient.newBuilder()
                .withCredential(credentials)
                .withHttpConfig(httpConfig)
                .withEndpoint(clientConfigurations.getEndpoint())
                .build();

        if (LOG.isDebugEnabled()) {
            LOG.debug("Successfully initialized Image client");
        }
        return imageClient;
    }

    protected void insert(
            final CamelContext camelContext, final String correlationId, final Exchange exchange, String repositoryName,
            final Long version, final boolean completed)
            throws Exception {
         
        int totalParameterIndex = 2;
        StringBuilder queryBuilder = new StringBuilder(256)
                .append("INSERT INTO ").append(repositoryName)
                .append('(')
                .append(EXCHANGE).append(", ")
                .append(ID);

        if (isStoreBodyAsText()) {
            queryBuilder.append(", ").append(BODY);
            totalParameterIndex++;
        }

        if (hasHeadersToStoreAsText()) {
            for (String headerName : getHeadersToStoreAsText()) {
                queryBuilder.append(", ").append(headerName);
                totalParameterIndex++;
            }
        }

        queryBuilder.append(") VALUES (");

        queryBuilder.append("?, ".repeat(Math.max(0, totalParameterIndex - 1)));
        queryBuilder.append("?)");

        queryBuilder.append(" ON CONFLICT DO NOTHING");

        String sql = queryBuilder.toString();

        int updateCount = insertHelper(camelContext, correlationId, exchange, sql, 1L, completed);
        if (updateCount == 0 && getRepositoryName().equals(repositoryName)) {
            throw new DataIntegrityViolationException("No row was inserted due to data violation");
        }
    }

    public Exchange recover(CamelContext camelContext, final String exchangeId) {
        Exchange answer = null;

        try {
            byte[] completedLDBKey = keyBuilder(getRepositoryNameCompleted(), exchangeId);

            byte[] rc = levelDBFile.getDb().get(completedLDBKey);

            if (rc != null) {
                answer = codec().unmarshallExchange(camelContext, rc);
            }
        } catch (IOException e) {
            throw new RuntimeCamelException(
                    "Error recovering exchangeId " + exchangeId + " from repository " + repositoryName, e);
        }

        LOG.debug("Recovering exchangeId [{}] -> {}", exchangeId, answer);
        return answer;
    }

        public Destination resolveDestinationName(
                Session session, String destinationName,
                boolean pubSubDomain)
                throws JMSException {
            QueueReplyManager.this.lock.lock();
            try {
                 
                if (destination == null) {
                    destination = delegate.resolveDestinationName(session, destinationName, pubSubDomain);
                    setReplyTo(destination);
                }
            } finally {
                QueueReplyManager.this.lock.unlock();
            }
            return destination;
        }

    public ActiveMQQueueEndpoint(String endpointUri, String destination, QueueBrowseStrategy queueBrowseStrategy) {
        super(endpointUri, destination, false);
        setDestinationType("queue");
        if (queueBrowseStrategy == null) {
            this.queueBrowseStrategy = createQueueBrowseStrategy();
        } else {
            this.queueBrowseStrategy = queueBrowseStrategy;
        }
    }

    void logUsageSummary(Logger log, String name, int pooled) {
        if (statisticsEnabled && processor != null) {
             
            long created = statistics.getCreatedCounter();
            long acquired = statistics.getAcquiredCounter();
            long released = statistics.getReleasedCounter();
            long discarded = statistics.getDiscardedCounter();
            boolean shouldLog = pooled > 0 || created > 0 || acquired > 0 || released > 0 || discarded > 0;
            if (shouldLog) {
                String rid = getRouteId();
                String pid = getId();

                 
                boolean leak = created + acquired > released + discarded;
                if (leak) {
                    long leaks = (created + acquired) - (released + discarded);
                    log.warn(
                            "{} {} ({}) usage (leaks detected: {}) [pooled: {}, created: {}, acquired: {} released: {}, discarded: {}]",
                            name, rid, pid, leaks, pooled, created, acquired, released, discarded);
                } else {
                    log.info("{} {} ({}) usage [pooled: {}, created: {}, acquired: {} released: {}, discarded: {}]",
                            name, rid, pid, pooled, created, acquired, released, discarded);
                }
            }
        }
    }

    public KeyPair generateKeyPair(String algorithm, String keyId, Object parameterSpec) throws Exception {
        LOG.info("Generating key pair for algorithm: {}, keyId: {}", algorithm, keyId);

        KeyPairGenerator generator;
        String provider = determineProvider(algorithm);

        if (provider != null) {
            generator = KeyPairGenerator.getInstance(getAlgorithmName(algorithm), provider);
        } else {
            generator = KeyPairGenerator.getInstance(getAlgorithmName(algorithm));
        }

         
        if (parameterSpec != null) {
            if (parameterSpec instanceof AlgorithmParameterSpec) {
                generator.initialize((AlgorithmParameterSpec) parameterSpec, new SecureRandom());
            } else if (parameterSpec instanceof Integer) {
                generator.initialize((Integer) parameterSpec, new SecureRandom());
            }
        } else {
             
            AlgorithmParameterSpec defaultSpec = getDefaultParameterSpec(algorithm);
            if (defaultSpec != null) {
                generator.initialize(defaultSpec, new SecureRandom());
            } else {
                generator.initialize(getDefaultKeySize(algorithm), new SecureRandom());
            }
        }

        KeyPair keyPair = generator.generateKeyPair();

         
        KeyMetadata metadata = new KeyMetadata(keyId, algorithm);
        metadata.setDescription("Generated on " + new Date());

         
        storeKey(keyId, keyPair, metadata);

        LOG.info("Generated key pair in AWS Secrets Manager: {}", metadata);
        return keyPair;
    }

    protected int poll() throws Exception {
        Object feed = createFeed();
        if (feed != null) {
            Exchange exchange = endpoint.createExchange(feed);
            getProcessor().process(exchange);
            return 1;
        } else {
            return 0;
        }
    }

    public Object sendBodyAndHeader(
            String endpoint, ExchangePattern pattern, final Object body,
            final String header, final Object headerValue)
            throws CamelExecutionException {
        Exchange exchange = send(endpoint, pattern, createBodyAndHeaderProcessor(body, header, headerValue));
        Object result = extractResultBody(exchange, pattern);
        if (pattern == ExchangePattern.InOnly) {
             
            return null;
        } else {
            return result;
        }
    }

    public Subscriber<Exchange> subscriber(String uri) {
        try {
            String uuid = context.getUuidGenerator().generateUuid();
            context.addRoutes(new RouteBuilder() {
                @Override
                public void configure() throws Exception {
                    from("reactive-streams:" + uuid)
                            .to(uri);
                }
            });

            return streamSubscriber(uuid);
        } catch (Exception e) {
            throw new IllegalStateException("Unable to create source reactive stream towards direct URI: " + uri, e);
        }
    }

    void attach(ReactiveStreamsProducer producer) {
        lock.lock();
        try {
            Objects.requireNonNull(producer, "producer cannot be null, use the detach method");

            if (this.camelProducer != null) {
                throw new IllegalStateException("A producer is already attached to the stream '" + name + "'");
            }

            if (this.camelProducer != producer) {  
                detach();

                ReactiveStreamsBackpressureStrategy strategy = producer.getEndpoint().getBackpressureStrategy();
                Flux<Exchange> flux = Flux.create(camelSink::set, FluxSink.OverflowStrategy.IGNORE);

                if (ObjectHelper.equal(strategy, ReactiveStreamsBackpressureStrategy.OLDEST)) {
                     
                    flux = flux.onBackpressureDrop(this::onBackPressure).handle(this::onItemEmitted);
                } else if (ObjectHelper.equal(strategy, ReactiveStreamsBackpressureStrategy.LATEST)) {
                     
                     
                    flux = flux.handle(this::onItemEmitted).onBackpressureLatest();
                } else {
                     
                    flux = flux.onBackpressureBuffer(Queues.SMALL_BUFFER_SIZE, this::onBackPressure)
                            .handle(this::onItemEmitted);
                }

                flux.subscribe(this.publisher);

                camelProducer = producer;
            }
        } finally {
            lock.unlock();
        }
    }

    public Long toLong(JsonNode node, Exchange exchange) throws Exception {
        if (node instanceof NumericNode) {
            NumericNode nn = (NumericNode) node;
            if (nn.canConvertToLong()) {
                return nn.asLong();
            }
        }
        String text = node.asText();
        return Long.valueOf(text);
    }

    protected void doStart() throws Exception {
        super.doStart();

        String accessKey = System.getenv(CAMEL_AWS_VAULT_ACCESS_KEY_ENV);
        String secretKey = System.getenv(CAMEL_AWS_VAULT_SECRET_KEY_ENV);
        String region = System.getenv(CAMEL_AWS_VAULT_REGION_ENV);
        boolean useDefaultCredentialsProvider
                = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_USE_DEFAULT_CREDENTIALS_PROVIDER_ENV));
        boolean useProfileCredentialsProvider
                = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_USE_PROFILE_CREDENTIALS_PROVIDER_ENV));
        String profileName = System.getenv(CAMEL_AWS_VAULT_PROFILE_NAME_ENV);
        boolean isOverrideEndpoint = Boolean.parseBoolean(System.getenv(CAMEL_AWS_VAULT_IS_OVERRIDE_ENDPOINT));
        String uriEndpointOverride = System.getenv(CAMEL_AWS_VAULT_URI_ENDPOINT_OVERRIDE);
        if (ObjectHelper.isEmpty(accessKey) && ObjectHelper.isEmpty(secretKey) && ObjectHelper.isEmpty(region)) {
            AwsVaultConfiguration awsVaultConfiguration = getCamelContext().getVaultConfiguration().aws();
            if (ObjectHelper.isNotEmpty(awsVaultConfiguration)) {
                accessKey = awsVaultConfiguration.getAccessKey();
                secretKey = awsVaultConfiguration.getSecretKey();
                region = awsVaultConfiguration.getRegion();
                useDefaultCredentialsProvider = awsVaultConfiguration.isDefaultCredentialsProvider();
                useProfileCredentialsProvider = awsVaultConfiguration.isProfileCredentialsProvider();
                profileName = awsVaultConfiguration.getProfileName();
                isOverrideEndpoint = awsVaultConfiguration.isOverrideEndpoint();
                uriEndpointOverride = awsVaultConfiguration.getUriEndpointOverride();
            }
        }
        this.region = region;
        if (ObjectHelper.isNotEmpty(accessKey) && ObjectHelper.isNotEmpty(secretKey) && ObjectHelper.isNotEmpty(region)) {
            SsmClientBuilder clientBuilder = SsmClient.builder();
            AwsBasicCredentials cred = AwsBasicCredentials.create(accessKey, secretKey);
            clientBuilder = clientBuilder.credentialsProvider(StaticCredentialsProvider.create(cred));
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else if (useDefaultCredentialsProvider && ObjectHelper.isNotEmpty(region)) {
            this.defaultCredentialsProvider = true;
            SsmClientBuilder clientBuilder = SsmClient.builder();
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else if (useProfileCredentialsProvider && ObjectHelper.isNotEmpty(profileName)) {
            this.profleCredentialsProvider = true;
            this.profileName = profileName;
            SsmClientBuilder clientBuilder = SsmClient.builder();
            clientBuilder.credentialsProvider(ProfileCredentialsProvider.create(profileName));
            clientBuilder.region(Region.of(region));
            if (isOverrideEndpoint) {
                if (ObjectHelper.isNotEmpty(uriEndpointOverride)) {
                    clientBuilder.endpointOverride(URI.create(uriEndpointOverride));
                }
            }
            client = clientBuilder.build();
        } else {
            throw new RuntimeCamelException(
                    "Using the AWS Parameter Store Properties Function requires setting AWS credentials as application properties or environment variables");
        }
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jph = (JsonObject) root.get("platform-http");
                        if (jph != null) {
                            String server = jph.getString("server");
                            JsonArray arr = (JsonArray) jph.get("endpoints");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    JsonObject jo = (JsonObject) arr.get(i);
                                    row.server = server;
                                    row.url = jo.getString("url");
                                    row.path = jo.getString("path");
                                    row.verbs = jo.getString("verbs");
                                    row.consumes = jo.getString("consumes");
                                    row.produces = jo.getString("produces");
                                    rows.add(row);
                                }
                            }
                            if (all) {
                                arr = (JsonArray) jph.get("managementEndpoints");
                                if (arr != null) {
                                    for (int i = 0; i < arr.size(); i++) {
                                        row = row.copy();
                                        JsonObject jo = (JsonObject) arr.get(i);
                                        row.server = server;
                                        row.url = jo.getString("url");
                                        row.path = jo.getString("path");
                                        row.verbs = jo.getString("verbs");
                                        row.consumes = jo.getString("consumes");
                                        row.produces = jo.getString("produces");
                                        rows.add(row);
                                    }
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("URL").dataAlign(HorizontalAlign.LEFT).with(r -> r.url),
                    new Column().header("METHOD").dataAlign(HorizontalAlign.LEFT).with(r -> r.verbs),
                    new Column().header("CONTENT-TYPE").dataAlign(HorizontalAlign.LEFT).with(this::getContent))));
        }

        return 0;
    }

    private static void toResult(Source source, Result result) throws TransformerException {
        if (source != null) {
            XMLConverterHelper xml = new XMLConverterHelper();
            TransformerFactory factory = xml.getTransformerFactory();
            Transformer transformer = factory.newTransformer();
            if (transformer == null) {
                throw new TransformerException("Could not create a transformer - JAXP is misconfigured!");
            } else {
                Properties outputProperties = new Properties();
                outputProperties.put("encoding", DEFAULT_CHARSET);
                outputProperties.put("omit-xml-declaration", "yes");

                transformer.setOutputProperties(outputProperties);
                transformer.transform(source, result);
            }
        }
    }

    protected AbstractGitHubProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);
        this.endpoint = endpoint;

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_REPOSITORY_SERVICE);
        if (service != null) {
            repositoryService = (RepositoryService) service;
        } else {
            repositoryService = new RepositoryService();
        }
        initService(repositoryService);
        repository = repositoryService.getRepository(endpoint.getRepoOwner(), endpoint.getRepoName());
    }

    private Object handleProducts(Exchange exchange, String method) throws Exception {
        switch (method) {
            case StripeConstants.METHOD_CREATE:
                return Product.create(getParametersFromBody(exchange));
            case StripeConstants.METHOD_RETRIEVE:
                String id = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                return Product.retrieve(id);
            case StripeConstants.METHOD_UPDATE:
                String productId = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                Product product = Product.retrieve(productId);
                return product.update(getParametersFromBody(exchange));
            case StripeConstants.METHOD_DELETE:
                String deleteId = exchange.getIn().getHeader(StripeConstants.OBJECT_ID, String.class);
                Product deleteProduct = Product.retrieve(deleteId);
                return deleteProduct.delete();
            case StripeConstants.METHOD_LIST:
                return Product.list(getParametersFromBody(exchange));
            default:
                throw new IllegalArgumentException("Unsupported method for products: " + method);
        }
    }

    public static void setField(Field f, Object instance, Object value) {
        try {
            boolean oldAccessible = f.canAccess(instance);
            boolean shouldSetAccessible = !Modifier.isPublic(f.getModifiers()) && !oldAccessible;
            if (shouldSetAccessible) {
                f.setAccessible(true);
            }
            f.set(instance, value);
            if (shouldSetAccessible) {
                f.setAccessible(oldAccessible);
            }
        } catch (IllegalArgumentException ex) {
            throw new UnsupportedOperationException("Cannot inject value of class: " + value.getClass() + " into: " + f);
        } catch (IllegalAccessException ex) {
            handleReflectionException(ex);
        }
    }

    private Exchange createExchangeFromBlob(final String blobName, final BlobContainerClient blobContainerClient)
            throws IOException {
        final BlobClientWrapper clientWrapper
                = new BlobClientWrapper(blobContainerClient.getBlobClient(blobName));
        final BlobOperations operations = new BlobOperations(getEndpoint().getConfiguration(), clientWrapper);
        final Exchange exchange = createExchange(true);

        BlobOperationResponse response;
        if (!ObjectHelper.isEmpty(getEndpoint().getConfiguration().getFileDir())) {
             
            response = operations.downloadBlobToFile(exchange);
        } else {
             
            response = operations.getBlob(exchange);
        }

        getEndpoint().setResponseOnExchange(response, exchange);

        exchange.getIn().setHeader(BlobConstants.BLOB_NAME, blobName);
        return exchange;
    }

    public MessageHistory newMessageHistory(String routeId, NamedNode namedNode, Exchange exchange) {
        if (nodePattern != null) {
            String name = namedNode.getShortName();
            String[] parts = nodePattern.split(",");
            for (String part : parts) {
                boolean match = PatternHelper.matchPattern(name, part);
                if (!match) {
                    return null;
                }
            }
        }

        Message msg = null;
        if (copyMessage) {
            msg = exchange.getMessage().copy();
        }

        Route route = camelContext.getRoute(routeId);
        if (route != null) {
            return new MicrometerMessageHistory(getMeterRegistry(), route, namedNode, getNamingStrategy(), msg);
        } else {
            return null;
        }
    }

    public <T> Set<T> findByType(Class<T> type) {
        String keyPrefix = type.getName().replace('$', '/');
        Set<T> result = new HashSet<>();

        List<String> keys;
        try {
            keys = kvClient.getKeys(keyPrefix);
        } catch (ConsulException e) {
            return result;
        }

        if (keys != null) {
            Object obj;

            for (String key : keys) {
                 
                key = key.substring(key.lastIndexOf('/') + 1);
                obj = lookupByName(key.replace('$', '/'));
                if (type.isInstance(obj)) {
                    result.add(type.cast(obj));
                }
            }
        }
        return result;
    }

    private void getGroupUsers(Exchange exchange, ClientConfigurations clientConfigurations) {
         
        if (ObjectHelper.isEmpty(clientConfigurations.getGroupId())) {
            if (LOG.isErrorEnabled()) {
                LOG.error("No group id given");
            }
            throw new IllegalArgumentException("Group id is mandatory to get group users");
        }

         
        KeystoneListUsersForGroupByAdminRequest request = new KeystoneListUsersForGroupByAdminRequest()
                .withGroupId(clientConfigurations.getGroupId());
        KeystoneListUsersForGroupByAdminResponse response = iamClient.keystoneListUsersForGroupByAdmin(request);
        exchange.getMessage().setBody(gson.toJson(response.getUsers()));
    }

    private boolean dumpTraceFiles(Map<Long, Pid> pids, int tail, Date limit) {
        Set<String> names = new HashSet<>();
        List<Row> rows = new ArrayList<>();
        for (Pid pid : pids.values()) {
            Queue<String> queue = pid.fifo;
            if (queue != null) {
                for (String l : queue) {
                    names.add(pid.name);
                    List<Row> parsed = parseTraceLine(pid, l);
                    if (parsed != null && !parsed.isEmpty()) {
                        rows.addAll(parsed);
                    }
                }
                pid.fifo.clear();
            }
        }

         
        if (names.size() > 1) {
             
            final Map<String, Long> lastTimestamp = new HashMap<>();
            rows.sort((r1, r2) -> {
                long t1 = r1.timestamp;
                long t2 = r2.timestamp;
                if (t1 == 0) {
                    t1 = lastTimestamp.get(r1.name);
                }
                if (t1 == 0) {
                    t1 = lastTimestamp.get(r2.name);
                }
                if (t1 == 0 && t2 == 0) {
                    return 0;
                } else if (t1 == 0) {
                    return -1;
                } else if (t2 == 0) {
                    return 1;
                }
                lastTimestamp.put(r1.name, t1);
                lastTimestamp.put(r2.name, t2);
                return Long.compare(t1, t2);
            });
        }
        if (tail > 0) {
             
            int pos = rows.size() - tail;
            if (pos > 0) {
                rows = rows.subList(pos, rows.size());
            }
        }

        int doneTraces = 0;
        for (Row r : rows) {
            printTrace(r.name, pids.size(), r, limit);
            if (r.done) {
                doneTraces++;
            }
        }

        if (latest) {
             
            return doneTraces == 0;
        } else {
            return true;
        }
    }

    public static <I1, I2, T extends Throwable> BiConsumer<I1, I2> wrapAsBiConsumer(ThrowingBiConsumer<I1, I2, T> consumer) {
        return new BiConsumer<>() {
            @Override
            public void accept(I1 i1, I2 i2) {
                try {
                    consumer.accept(i1, i2);
                } catch (Throwable t) {
                    throw new RuntimeException(t);
                }
            }
        };
    }

    public String summaryErrorMessage(boolean includeHeader, boolean ignoreDeprecated, boolean includeWarnings) {
        boolean ok = isSuccess();

         
        if (ok && !ignoreDeprecated) {
            ok = deprecated == null;
        }

        if (includeWarnings) {
            if (incapable != null) {
                return "\tIncapable of parsing uri: " + incapable;
            } else if (syntaxError != null) {
                return "\tSyntax error: " + syntaxError;
            } else if (unknownComponent != null) {
                return "\tUnknown component: " + unknownComponent;
            }
        }

        if (ok) {
            return null;
        }

         
        Map<String, String> options = new LinkedHashMap<>();
        if (unknown != null) {
            for (String name : unknown) {
                if (unknownSuggestions != null && unknownSuggestions.containsKey(name)) {
                    String[] suggestions = unknownSuggestions.get(name);
                    if (suggestions != null && suggestions.length > 0) {
                        String str = Arrays.asList(suggestions).toString();
                        options.put(name, "Unknown option. Did you mean: " + str);
                    } else {
                        options.put(name, "Unknown option");
                    }
                } else {
                    options.put(name, "Unknown option");
                }
            }
        }
        if (notConsumerOnly != null) {
            for (String name : notConsumerOnly) {
                options.put(name, "Option not applicable in consumer only mode");
            }
        }
        if (notProducerOnly != null) {
            for (String name : notProducerOnly) {
                options.put(name, "Option not applicable in producer only mode");
            }
        }
        if (required != null) {
            for (String name : required) {
                options.put(name, "Missing required option");
            }
        }
        if (deprecated != null) {
            for (String name : deprecated) {
                options.put(name, "Deprecated option");
            }
        }
        if (invalidEnum != null) {
            for (Map.Entry<String, String> entry : invalidEnum.entrySet()) {
                String name = entry.getKey();
                String[] choices = invalidEnumChoices.get(name);
                String defaultValue = defaultValues != null ? defaultValues.get(entry.getKey()) : null;
                String str = Arrays.asList(choices).toString();
                String msg = "Invalid enum value: " + entry.getValue() + ". Possible values: " + str;
                if (invalidEnumSuggestions != null) {
                    String[] suggestions = invalidEnumSuggestions.get(name);
                    if (suggestions != null && suggestions.length > 0) {
                        str = Arrays.asList(suggestions).toString();
                        msg += ". Did you mean: " + str;
                    }
                }
                if (defaultValue != null) {
                    msg += ". Default value: " + defaultValue;
                }

                options.put(entry.getKey(), msg);
            }
        }
        if (invalidReference != null) {
            for (Map.Entry<String, String> entry : invalidReference.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty reference value");
                } else if (!entry.getValue().startsWith("#")) {
                    options.put(entry.getKey(), "Invalid reference value: " + entry.getValue() + " must start with #");
                } else {
                    options.put(entry.getKey(), "Invalid reference value: " + entry.getValue());
                }
            }
        }
        if (invalidBoolean != null) {
            for (Map.Entry<String, String> entry : invalidBoolean.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty boolean value");
                } else {
                    options.put(entry.getKey(), "Invalid boolean value: " + entry.getValue());
                }
            }
        }
        if (invalidInteger != null) {
            for (Map.Entry<String, String> entry : invalidInteger.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty integer value");
                } else {
                    options.put(entry.getKey(), "Invalid integer value: " + entry.getValue());
                }
            }
        }
        if (invalidNumber != null) {
            for (Map.Entry<String, String> entry : invalidNumber.entrySet()) {
                boolean empty = isEmpty(entry.getValue());
                if (empty) {
                    options.put(entry.getKey(), "Empty number value");
                } else {
                    options.put(entry.getKey(), "Invalid number value: " + entry.getValue());
                }
            }
        }

         
         
        int maxLen = 24;
        for (String key : options.keySet()) {
            maxLen = Math.max(maxLen, key.length());
        }
        String format = "%" + maxLen + "s    %s";

         
        StringBuilder sb = new StringBuilder(512);
        if (includeHeader) {
            sb.append("Endpoint validator error\n");
            sb.append(
                    "---------------------------------------------------------------------------------------------------------------------------------------\n");
            sb.append("\n");
        }
        if (uri != null) {
            sb.append("\t").append(uri).append("\n");
        } else {
            sb.append("\n");
        }
        for (Map.Entry<String, String> option : options.entrySet()) {
            String out = String.format(format, option.getKey(), option.getValue());
            sb.append("\n\t").append(out);
        }

        return sb.toString();
    }

    public Integer doProcessWatchCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                     
                    if (root != null) {
                        Row row = new Row();
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        row.pid = Long.toString(ph.pid());
                        row.uptime = extractSince(ph);
                        row.age = TimeUtils.printSince(row.uptime);

                        JsonObject jo = (JsonObject) root.get("services");
                        if (jo != null) {
                            JsonArray arr = (JsonArray) jo.get("services");
                            if (arr != null) {
                                for (int i = 0; i < arr.size(); i++) {
                                    row = row.copy();
                                    jo = (JsonObject) arr.get(i);
                                    row.component = jo.getString("component");
                                    row.direction = jo.getString("direction");
                                    row.hosted = jo.getBooleanOrDefault("hosted", false);
                                    row.protocol = jo.getString("protocol");
                                    row.serviceUrl = jo.getString("serviceUrl");
                                    row.endpointUri = jo.getString("endpointUri");
                                    row.hits = jo.getLongOrDefault("hits", 0);
                                    row.routeId = jo.getString("routeId");
                                    row.metadata = jo.getMap("metadata");
                                    rows.add(row);
                                }
                            }
                        }
                    }
                });

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printer().println(AsciiTable.getTable(AsciiTable.NO_BORDERS, rows, Arrays.asList(
                    new Column().header("PID").headerAlign(HorizontalAlign.CENTER).with(r -> r.pid),
                    new Column().header("NAME").dataAlign(HorizontalAlign.LEFT).maxWidth(30, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(r -> r.name),
                    new Column().header("COMPONENT").dataAlign(HorizontalAlign.LEFT).with(r -> r.component),
                    new Column().header("DIR").dataAlign(HorizontalAlign.LEFT).with(r -> r.direction),
                    new Column().header("ROUTE").dataAlign(HorizontalAlign.LEFT).with(this::getRouteId),
                    new Column().header("PROTOCOL").dataAlign(HorizontalAlign.LEFT).with(this::getProtocol),
                    new Column().header("SERVICE").dataAlign(HorizontalAlign.LEFT).with(this::getService),
                    new Column().header("METADATA").visible(metadata).dataAlign(HorizontalAlign.LEFT).with(this::getMetadata),
                    new Column().header("TOTAL").dataAlign(HorizontalAlign.RIGHT).with(r -> "" + r.hits),
                    new Column().header("ENDPOINT").visible(!wideUri).dataAlign(HorizontalAlign.LEFT)
                            .maxWidth(90, OverflowBehaviour.ELLIPSIS_RIGHT)
                            .with(this::getUri),
                    new Column().header("ENDPOINT").visible(wideUri).dataAlign(HorizontalAlign.LEFT)
                            .maxWidth(140, OverflowBehaviour.NEWLINE)
                            .with(this::getUri))));
        }

        return 0;
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    protected Object[] createProperties() {
        Object[] properties = new Object[7];
        properties[0] = asResultType();
        properties[1] = definition.getInstance();
        properties[2] = parseString(definition.getMethod());
        properties[3] = definition.getBeanType();
        properties[4] = parseString(definition.getRef());
        properties[5] = parseString(definition.getScope());
        properties[6] = parseString(definition.getValidate());
        return properties;
    }

    private Region messageToRegion(Message message) {
        Region region = message.getBody(Region.class);
        if (region == null) {
            Map headers = message.getHeaders();
            RegionBuilder builder = Builders.region();

            if (headers.containsKey(KeystoneConstants.DESCRIPTION)) {
                builder.description(message.getHeader(KeystoneConstants.DESCRIPTION, String.class));
            }

            region = builder.build();
        }

        return region;
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (useJmx) {
            ManagementAgent agent = getCamelContext().getManagementStrategy().getManagementAgent();
            if (agent != null) {
                MBeanServer server = agent.getMBeanServer();
                if (server != null) {
                    reporter = JmxReporter.forRegistry(metricsRegistry).registerWith(server).inDomain(jmxDomain).build();
                    reporter.start();
                }
            } else {
                throw new IllegalStateException("CamelContext has not enabled JMX");
            }
        }
    }

    protected void prepareDataFormatConfig(Map<String, Object> properties) {
        properties.put("keyUserid", definition.getKeyUserid());
        properties.put("signatureKeyUserid", definition.getSignatureKeyUserid());
        properties.put("password", definition.getPassword());
        properties.put("signaturePassword", definition.getSignaturePassword());
        properties.put("keyFileName", definition.getKeyFileName());
        properties.put("signatureKeyFileName", definition.getSignatureKeyFileName());
        properties.put("signatureKeyRing", definition.getSignatureKeyRing());
        properties.put("armored", definition.getArmored());
        properties.put("integrity", definition.getIntegrity());
        properties.put("provider", definition.getProvider());
        properties.put("algorithm", definition.getAlgorithm());
        properties.put("compressionAlgorithm", definition.getCompressionAlgorithm());
        properties.put("hashAlgorithm", definition.getHashAlgorithm());
        properties.put("signatureVerificationOption", definition.getSignatureVerificationOption());
    }

    public Exchange create(boolean autoRelease) {
        Exchange exchange = pool.poll();
        if (exchange == null) {
             
            exchange = createPooledExchange(null, autoRelease);
            if (statisticsEnabled) {
                statistics.created.increment();
            }
        } else {
            if (statisticsEnabled) {
                statistics.acquired.increment();
            }
        }

         
        ((ResetableClock) exchange.getClock()).reset();

        return exchange;
    }

        protected void decodeStructuredContent(Exchange exchange, Map<String, Object> content) {
            final CloudEvent ce = cloudEvent();
            final Message message = exchange.getIn();

             
            ifNotEmpty(content.remove("data"), message::setBody);

            ifNotEmpty(content.remove(ce.mandatoryAttribute(CloudEvent.CAMEL_CLOUD_EVENT_DATA_CONTENT_TYPE).json()), val -> {
                message.setHeader(Exchange.CONTENT_TYPE, val);
            });

            for (CloudEvent.Attribute attribute : ce.attributes()) {
                ifNotEmpty(content.remove(attribute.json()), val -> {
                    message.setHeader(attribute.id(), val);
                });
            }

             
             
             
            content.forEach((key, val) -> {
                message.setHeader(key.toLowerCase(Locale.US), val);
            });
        }

        public void parse(String systemId) throws IOException, SAXException {
            lock.lock();
            try {
                checkValid();
                try {
                    xmlReader.parse(systemId);
                } finally {
                    release();
                }
            } finally {
                lock.unlock();
            }
        }

    public int read(byte[] b, int off, int len) throws IOException {
        int tlen = 0;
        while (len > 0) {
            int n = ensureBuffering(len);
            if (n < 0) {
                break;
            }
            int clen = Math.min(len, n);
            System.arraycopy(buffer, 0, b, off, clen);
            System.arraycopy(buffer, clen, buffer, 0, buffer.length - clen);
            bpos -= clen;
            len -= clen;
            off += clen;
            tlen += clen;
        }

        return tlen > 0 ? tlen : -1;
    }

    public PathHandler addExactPath(final String path, final HttpHandler handler) {
        lock.lock();
        try {
            super.addExactPath(path, handler);
            handlers.put(path, handler);
            handlerString = null;
            return this;
        } finally {
            lock.unlock();
        }
    }

    public Set<PosixFilePermission> getPermissions() {
        Set<PosixFilePermission> permissions = EnumSet.noneOf(PosixFilePermission.class);
        if (ObjectHelper.isEmpty(chmod)) {
            return permissions;
        }

        String chmodString = chmod.substring(chmod.length() - 3);  
                                                                  
                                                                  

        int ownerValue = Integer.parseInt(chmodString.substring(0, 1));
        int groupValue = Integer.parseInt(chmodString.substring(1, 2));
        int othersValue = Integer.parseInt(chmodString.substring(2, 3));

        if ((ownerValue & CHMOD_WRITE_MASK) > 0) {
            permissions.add(PosixFilePermission.OWNER_WRITE);
        }
        if ((ownerValue & CHMOD_READ_MASK) > 0) {
            permissions.add(PosixFilePermission.OWNER_READ);
        }
        if ((ownerValue & CHMOD_EXECUTE_MASK) > 0) {
            permissions.add(PosixFilePermission.OWNER_EXECUTE);
        }

        if ((groupValue & CHMOD_WRITE_MASK) > 0) {
            permissions.add(PosixFilePermission.GROUP_WRITE);
        }
        if ((groupValue & CHMOD_READ_MASK) > 0) {
            permissions.add(PosixFilePermission.GROUP_READ);
        }
        if ((groupValue & CHMOD_EXECUTE_MASK) > 0) {
            permissions.add(PosixFilePermission.GROUP_EXECUTE);
        }

         
        if ((othersValue & CHMOD_WRITE_MASK) > 0) {
            permissions.add(PosixFilePermission.OTHERS_WRITE);  
        }
        if ((othersValue & CHMOD_READ_MASK) > 0) {
            permissions.add(PosixFilePermission.OTHERS_READ);  
        }
        if ((othersValue & CHMOD_EXECUTE_MASK) > 0) {
            permissions.add(PosixFilePermission.OTHERS_EXECUTE);  
        }

        return permissions;
    }

    private void doLoadKnownDependencies(String name) {
        try {
            Enumeration<URL> resources = getClass().getClassLoader().getResources(name);
            while (resources.hasMoreElements()) {
                URL resource = resources.nextElement();
                try (InputStream is = resource.openStream()) {
                    Properties prop = new Properties();
                    prop.load(is);
                    Map<String, String> map = new HashMap<>();
                    for (String key : prop.stringPropertyNames()) {
                        String value = prop.getProperty(key);
                        map.put(key, value);
                    }
                    addMappings(map);
                }
            }
        } catch (Exception e) {
             
        }
    }

    private void tailTraceFiles(Map<Long, Pid> pids, int tail) throws Exception {
        for (Pid pid : pids.values()) {
            Path file = getTraceFile(pid.pid);
            if (Files.exists(file)) {
                pid.reader = new LineNumberReader(Files.newBufferedReader(file));
                String line;
                if (tail <= 0) {
                    pid.fifo = new ArrayDeque<>();
                } else {
                    pid.fifo = new ArrayBlockingQueue<>(tail);
                }
                do {
                    line = pid.reader.readLine();
                    if (line != null) {
                        while (!pid.fifo.offer(line)) {
                            pid.fifo.poll();
                        }
                    }
                } while (line != null);
            }
        }
    }

    private boolean isValidGrep(String line) {
        if (grep == null) {
            return true;
        }
         
        line = unescapeAnsi(line);
        String after = StringHelper.after(line, "---", line);
        for (String g : grep) {
            boolean m = Pattern.compile("(?i)" + g).matcher(after).find();
            if (m) {
                return true;
            }
        }
        return false;
    }

    private void updatePids(Map<Long, Row> rows) {
        List<Long> pids = findPids(name);
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        Row row = new Row();
                        row.pid = Long.toString(ph.pid());
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        int len = row.name.length();
                        if (len < NAME_MIN_WIDTH) {
                            len = NAME_MIN_WIDTH;
                        }
                        if (len > NAME_MAX_WIDTH) {
                            len = NAME_MAX_WIDTH;
                        }
                        if (len > nameMaxWidth) {
                            nameMaxWidth = len;
                        }
                        if (!rows.containsKey(ph.pid())) {
                            rows.put(ph.pid(), row);
                        }
                    }
                });

         
        Set<Long> remove = new HashSet<>();
        for (long pid : rows.keySet()) {
            if (!pids.contains(pid)) {
                remove.add(pid);
            }
        }
        for (long pid : remove) {
            rows.remove(pid);
        }
    }

        public void run() {
            FilterWatchListDeletable<Service, ServiceList, ServiceResource<Service>> w;

             
            String namespace = getEndpoint().getKubernetesConfiguration().getNamespace();
            String labelKey = getEndpoint().getKubernetesConfiguration().getLabelKey();
            String labelValue = getEndpoint().getKubernetesConfiguration().getLabelValue();
            String resourceName = getEndpoint().getKubernetesConfiguration().getResourceName();

            if (ObjectHelper.isEmpty(namespace)) {
                w = getEndpoint().getKubernetesClient().services().inAnyNamespace();

                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = w.withLabel(labelKey, labelValue);
                }
            } else {
                final NonNamespaceOperation<Service, ServiceList, ServiceResource<Service>> client
                        = getEndpoint().getKubernetesClient().services().inNamespace(namespace);
                w = client;
                if (ObjectHelper.isNotEmpty(labelKey) && ObjectHelper.isNotEmpty(labelValue)) {
                    w = client.withLabel(labelKey, labelValue);
                } else if (ObjectHelper.isNotEmpty(resourceName)) {
                    w = (FilterWatchListDeletable<Service, ServiceList, ServiceResource<Service>>) client
                            .withName(resourceName);
                }
            }

            watch = w.watch(new Watcher<>() {

                @Override
                public void eventReceived(Action action, Service resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

                @Override
                public void onClose(WatcherException cause) {
                    if (cause != null) {
                        LOG.error(cause.getMessage(), cause);
                    }
                }

            });
        }

                public void eventReceived(Action action, Event resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

    public Exchange add(CamelContext camelContext, String key, Exchange oldExchange, Exchange newExchange)
            throws OptimisticLockingException {
        if (!optimistic) {
            throw new UnsupportedOperationException();
        }
        LOG.trace("Adding an Exchange with ID {} for key {} in an optimistic manner.", newExchange.getExchangeId(), key);
        if (oldExchange == null) {
            DefaultExchangeHolder holder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            final DefaultExchangeHolder misbehaviorHolder = replicatedCache.putIfAbsent(key, holder);
            if (misbehaviorHolder != null) {
                Exchange misbehaviorEx = unmarshallExchange(camelContext, misbehaviorHolder);
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#putIfAbsend returned Exchange with ID {}, while it's expected no exchanges to be returned",
                        key, misbehaviorEx != null ? misbehaviorEx.getExchangeId() : "<null>");
                throw new OptimisticLockingException();
            }
        } else {
            DefaultExchangeHolder oldHolder = DefaultExchangeHolder.marshal(oldExchange, true, allowSerializedHeaders);
            DefaultExchangeHolder newHolder = DefaultExchangeHolder.marshal(newExchange, true, allowSerializedHeaders);
            if (!replicatedCache.replace(key, oldHolder, newHolder)) {
                LOG.error(
                        "Optimistic locking failed for exchange with key {}: IMap#replace returned no Exchanges, while it's expected to replace one",
                        key);
                throw new OptimisticLockingException();
            }
        }
        LOG.trace("Added an Exchange with ID {} for key {} in optimistic manner.", newExchange.getExchangeId(), key);
        return oldExchange;
    }

    protected void doCall(Map<String, Object> options, Function<ManagedRouteMBean, Object> task) {
        String path = (String) options.get(Exchange.HTTP_PATH);
        String subPath = path != null ? StringHelper.after(path, "/") : null;
        String filter = (String) options.get(FILTER);
        String limit = (String) options.get(LIMIT);
        final int max = limit == null ? Integer.MAX_VALUE : Integer.parseInt(limit);

        ManagedCamelContext mcc = getCamelContext().getCamelContextExtension().getContextPlugin(ManagedCamelContext.class);
        if (mcc != null) {
            List<Route> routes = getCamelContext().getRoutes();
            routes.sort((o1, o2) -> o1.getRouteId().compareToIgnoreCase(o2.getRouteId()));
            routes.stream()
                    .map(route -> mcc.getManagedRoute(route.getRouteId()))
                    .filter(Objects::nonNull)
                    .filter(r -> accept(r, filter))
                    .filter(r -> accept(r, subPath))
                    .sorted(SourceDevConsole::sort)
                    .limit(max)
                    .forEach(task::apply);
        }
    }

    public ProcessorDefinition<?> after() {
        RouteDefinition route = builder.getOriginalRoute();
        AdviceWithDefinition answer = new AdviceWithDefinition();
        if (id != null) {
            builder.getAdviceWithTasks()
                    .add(AdviceWithTasks.afterById(route, id, answer, selectFirst, selectLast, selectFrom, selectTo, maxDeep));
        } else if (toString != null) {
            builder.getAdviceWithTasks().add(AdviceWithTasks.afterByToString(route, toString, answer, selectFirst, selectLast,
                    selectFrom, selectTo, maxDeep));
        } else if (toUri != null) {
            builder.getAdviceWithTasks().add(
                    AdviceWithTasks.afterByToUri(route, toUri, answer, selectFirst, selectLast, selectFrom, selectTo, maxDeep));
        } else if (type != null) {
            builder.getAdviceWithTasks().add(
                    AdviceWithTasks.afterByType(route, type, answer, selectFirst, selectLast, selectFrom, selectTo, maxDeep));
        }
        return answer;
    }

    protected int sortRow(Row o1, Row o2) {
         
        int answer = super.sortRow(o1, o2);
        if (answer == 0) {
            int negate = 1;
            if (sort.startsWith("-")) {
                negate = -1;
            }
             
            long m1 = o1.mean != null ? Long.parseLong(o1.mean) : 0;
            long m2 = o2.mean != null ? Long.parseLong(o2.mean) : 0;
            if (m1 < m2) {
                answer = negate;
            } else if (m1 > m2) {
                answer = -1 * negate;
            }
        }
        return answer;
    }

    private void processGetBatch(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        String jobId;
        BatchInfo batchBody = exchange.getIn().getBody(BatchInfo.class);
        String batchId;
        if (batchBody != null) {
            jobId = batchBody.getJobId();
            batchId = batchBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, IGNORE_BODY, NOT_OPTIONAL);
            batchId = getParameter(BATCH_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getBatch(jobId, batchId, determineHeaders(exchange), new BulkApiClient.BatchInfoResponseCallback() {
            @Override
            public void onResponse(BatchInfo batchInfo, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, batchInfo, headers, ex, callback);
            }
        });
    }

    private void doLoadKnownRepos(String name) {
        try {
            InputStream is = getClass().getResourceAsStream(name);
            if (is != null) {
                Properties prop = new Properties();
                prop.load(is);
                Map<String, String> map = new HashMap<>();
                for (String key : prop.stringPropertyNames()) {
                    String value = prop.getProperty(key);
                    map.put(key, value);
                }
                addRepos(map);
            }
        } catch (Exception e) {
             
        }
    }

    public void completedExchange(Exchange exchange, long time) {
        if (counter1.isStatisticsEnabled()) {
            counter1.completedExchange(exchange, time);
        }
        if (counter2.isStatisticsEnabled()) {
            counter2.completedExchange(exchange, time);
        }
        if (counter3 != null && counter3.isStatisticsEnabled()) {
            counter3.completedExchange(exchange, time);
        }
    }

    public void execute() throws MojoExecutionException, MojoFailureException {
        if ("pom".equals(project.getPackaging())) {
            return;
        }

        buildDir = new File(project.getBuild().getDirectory());

        if (resourcesOutputDir == null) {
            resourcesOutputDir = new File(project.getBasedir(), "src/generated/resources");
        }

        Index index = PackagePluginUtils.readJandexIndexIgnoreMissing(project, getLog());
        if (index == null) {
            return;
        }

        List<DataTypeTransformerModel> models = new ArrayList<>();
        List<AnnotationInstance> annotations = index.getAnnotations(DATA_TYPE_ANNOTATION);
        annotations.forEach(a -> {
            DataTypeTransformerModel model = new DataTypeTransformerModel();

            String currentClass = a.target().asClass().name().toString();
            boolean deprecated
                    = a.target().asClass().hasAnnotation(Deprecated.class) || project.getName().contains("(deprecated)");
            model.setClassName(currentClass);
            model.setDeprecated(deprecated);
            model.setName(annotationValue(a, "name"));
            model.setFrom(annotationValue(a, "from"));
            model.setTo(annotationValue(a, "to"));
            model.setDescription(annotationValue(a, "description"));
            models.add(model);
        });
        models.sort(Comparator.comparing(DataTypeTransformerModel::getName));

        if (!models.isEmpty()) {
            try {
                StringJoiner names = new StringJoiner(" ");
                for (var model : models) {
                    names.add(model.getName());

                    JsonObject jo = asJsonObject(model);
                    String json = jo.toJson();
                    json = Jsoner.prettyPrint(json, 2);
                    String fn = sanitizeFileName(model.getName()) + PackageHelper.JSON_SUFIX;
                    boolean updated = updateResource(resourcesOutputDir.toPath(),
                            "META-INF/services/org/apache/camel/transformer/" + fn,
                            json + NL);
                    if (updated) {
                        getLog().info("Updated transformer json: " + model.getName());
                    }
                }

                 
                File camelMetaDir = new File(resourcesOutputDir, "META-INF/services/org/apache/camel/");
                int count = models.size();
                String properties = createProperties(project, "transformers", names.toString());
                updateResource(camelMetaDir.toPath(), "transformer.properties", properties);
                getLog().info("Generated transformer.properties containing " + count + " Camel "
                              + (count > 1 ? "transformers: " : "transformer: ") + names);
            } catch (Exception e) {
                throw new MojoExecutionException(e);
            }
        }
    }

    public BoxSharedLink createFileSharedLink(
            String fileId, BoxSharedLink.Access access, Date unshareDate,
            BoxSharedLink.Permissions permissions) {
        try {
            LOG.debug("Creating shared link for file(id={}) with access={} {}",
                    fileId, access, unshareDate == null
                            ? ""
                            : " unsharedDate=" + DateFormat.getDateTimeInstance().format(unshareDate)
                              + " permissions=" + permissions);

            BoxHelper.notNull(fileId, BoxHelper.FILE_ID);
            BoxHelper.notNull(access, "access");

            BoxFile file = new BoxFile(boxConnection, fileId);
            BoxSharedLinkRequest request = new BoxSharedLinkRequest();
            request.access(access).unsharedDate(unshareDate)
                    .permissions(permissions.getCanDownload(), permissions.getCanPreview(), permissions.getCanEdit());
            return file.createSharedLink(request);
        } catch (BoxAPIException e) {
            throw new RuntimeCamelException(BoxHelper.buildBoxApiErrorMessage(e), e);
        }
    }

    public void process(Exchange exchange) throws Exception {

        if (logger.isDebugEnabled()) {
             
             
             
            logger.debug("uploader thread/id: {} / {}. api call completed.", Thread.currentThread().getId(),
                    exchange.getExchangeId());
        }

        if (exchange.getIn().getBody() instanceof List) {
            boolean groupedExchanges = false;
            for (Object body : exchange.getIn().getBody(List.class)) {
                if (body instanceof Exchange) {
                    send((Exchange) body);
                    groupedExchanges = true;
                }
            }
            if (!groupedExchanges) {
                send(exchange);
            }
        } else {
            send(exchange);
        }
    }

    public DaprOperationResponse handle(Exchange exchange) {
        Object payload = exchange.getIn().getBody();
        String bindingName = configurationOptionsProxy.getBindingName(exchange);
        String bindingOperation = configurationOptionsProxy.getBindingOperation(exchange);
        Map<String, String> metadata = configurationOptionsProxy.getMetadata(exchange);

        InvokeBindingRequest bindingRequest = new InvokeBindingRequest(bindingName, bindingOperation);
        bindingRequest.setData(payload);
        bindingRequest.setMetadata(metadata);

        DaprClient client = endpoint.getClient();
        final byte[] response = client.invokeBinding(bindingRequest, TypeRef.get(byte[].class)).block();

        return DaprOperationResponse.create(response);
    }

    protected boolean isMatched(
            Supplier<GenericFile<ShareFileItem>> file, String doneFileName,
            ShareFileItem[] files) {
        String onlyName = FileUtil.stripPath(doneFileName);

        for (ShareFileItem f : files) {
            if (f.getName().equals(onlyName)) {
                return true;
            }
        }

        LOG.trace("Done file: {} does not exist", doneFileName);
        return false;
    }

    public Transformer resolve(TransformerKey key, CamelContext context) {
        String name = key.toString();
        TransformerModel model = catalog.transformerModel(name);
        if (model != null) {
            downloadLoader(model.getGroupId(), model.getArtifactId(), model.getVersion());
        }

        Transformer answer;
        boolean accept = accept(name);
        if (accept) {
            answer = super.resolve(key, context);
        } else {
            answer = new StubTransformer();
        }

        if (answer == null) {
            List<String> suggestion = SuggestSimilarHelper.didYouMean(catalog.findTransformerNames(), name);
            if (suggestion != null && !suggestion.isEmpty()) {
                String s = String.join(", ", suggestion);
                throw new IllegalArgumentException("Cannot find transformer with name: " + name + ". Did you mean: " + s);
            }
        }
        return answer;
    }

    public static String getType(String type, boolean enumType, boolean isDuration) {
        if (enumType) {
            return "enum";
        } else if (isDuration) {
            return "duration";
        } else if (type == null) {
             
            return "object";
        } else if (type.equals(URI.class.getName()) || type.equals(URL.class.getName())) {
            return "string";
        } else if (type.equals(File.class.getName())) {
            return "string";
        } else if (type.equals(Date.class.getName())) {
            return "string";
        } else if (type.startsWith("java.lang.Class")) {
            return "string";
        } else if (type.startsWith("java.util.List") || type.startsWith("java.util.Collection")) {
            return "array";
        }

        String primitive = getPrimitiveType(type);
        if (primitive != null) {
            return primitive;
        }

        return "object";
    }

    public boolean process(final Exchange exchange, final AsyncCallback callback) {
        boolean done = false;

        try {
            switch (operationName) {
                case BULK2_CREATE_JOB:
                    processCreateJob(exchange, callback);
                    break;
                case BULK2_GET_JOB:
                    processGetJob(exchange, callback);
                    break;
                case BULK2_CREATE_BATCH:
                    processCreateBatch(exchange, callback);
                    break;
                case BULK2_CLOSE_JOB:
                    processCloseJob(exchange, callback);
                    break;
                case BULK2_ABORT_JOB:
                    processAbortJob(exchange, callback);
                    break;
                case BULK2_DELETE_JOB:
                    deleteJob(exchange, callback);
                    break;
                case BULK2_GET_SUCCESSFUL_RESULTS:
                    processGetSuccessfulResults(exchange, callback);
                    break;
                case BULK2_GET_FAILED_RESULTS:
                    processGetFailedResults(exchange, callback);
                    break;
                case BULK2_GET_UNPROCESSED_RECORDS:
                    processGetUnprocessedRecords(exchange, callback);
                    break;
                case BULK2_GET_ALL_JOBS:
                    processGetAllJobs(exchange, callback);
                    break;
                case BULK2_CREATE_QUERY_JOB:
                    processCreateQueryJob(exchange, callback);
                    break;
                case BULK2_GET_QUERY_JOB:
                    processGetQueryJob(exchange, callback);
                    break;
                case BULK2_GET_QUERY_JOB_RESULTS:
                    processGetQueryJobResults(exchange, callback);
                    break;
                case BULK2_ABORT_QUERY_JOB:
                    processAbortQueryJob(exchange, callback);
                    break;
                case BULK2_DELETE_QUERY_JOB:
                    processDeleteQueryJob(exchange, callback);
                    break;
                case BULK2_GET_ALL_QUERY_JOBS:
                    processGetAllQueryJobs(exchange, callback);
                    break;
                default:
                    throw new SalesforceException(
                            "Unknown operation name: " + operationName.value(), null);
            }
        } catch (SalesforceException e) {
            exchange.setException(new SalesforceException(
                    String.format("Error processing %s: [%s] \"%s\"", operationName.value(),
                            e.getStatusCode(), e.getMessage()),
                    e));
            callback.done(true);
            done = true;
        } catch (InvalidPayloadException | RuntimeException e) {
            exchange.setException(new SalesforceException(
                    String.format("Unexpected Error processing %s: \"%s\"", operationName.value(),
                            e.getMessage()),
                    e));
            callback.done(true);
            done = true;
        }

         
        return done;
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.azure.servicebus.receiveMessages");

        if (message.getHeaders().containsKey(ServiceBusConstants.PARTITION_KEY)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "azure.servicebus.partition." + message.getHeader(ServiceBusConstants.PARTITION_KEY, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(ServiceBusConstants.MESSAGE_ID, String.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        if (message.getHeaders().containsKey(ServiceBusConstants.CONTENT_TYPE)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE,
                    message.getHeaders().containsKey(ServiceBusConstants.CONTENT_TYPE));
        } else {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        getCurrentSagaCoordinator(exchange).whenComplete((coordinator, ex) -> ifNotException(ex, exchange, callback, () -> {
            if (coordinator == null) {
                exchange.setException(new CamelExchangeException("Exchange is not part of a saga", exchange));
                callback.done(false);
            } else {
                coordinator.beginStep(exchange, step)
                        .whenComplete((done, ex2) -> ifNotException(ex2, exchange, callback, () -> {
                            super.process(exchange, doneSync -> callback.done(false));
                        }));
            }
        }));
        return false;
    }

                public void eventReceived(Action action, Service resource) {
                    Exchange exchange = createExchange(false);
                    exchange.getIn().setBody(resource);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_ACTION, action);
                    exchange.getIn().setHeader(KubernetesConstants.KUBERNETES_EVENT_TIMESTAMP, System.currentTimeMillis());
                    try {
                        processor.process(exchange);
                    } catch (Exception e) {
                        getExceptionHandler().handleException("Error during processing", exchange, e);
                    } finally {
                        releaseExchange(exchange, false);
                    }
                }

    protected void doStop() throws Exception {
        super.doStop();

        LOG.debug("Stopping Kubernetes HPA Consumer");
        if (executor != null) {
            KubernetesHelper.close(hpasWatcher, hpasWatcher::getWatch);

            if (getEndpoint() != null && getEndpoint().getCamelContext() != null) {
                getEndpoint().getCamelContext().getExecutorServiceManager().shutdownNow(executor);
            } else {
                executor.shutdownNow();
            }
        }
        executor = null;
    }

    public Calendar getClient(GoogleCalendarConfiguration config) {
        if (client == null) {
            if (config.getClientId() != null && !config.getClientId().isBlank()
                    && config.getClientSecret() != null && !config.getClientSecret().isBlank()) {
                client = getClientFactory().makeClient(config.getClientId(), config.getClientSecret(), config.getScopesAsList(),
                        config.getApplicationName(), config.getRefreshToken(),
                        config.getAccessToken(), config.getEmailAddress(), config.getP12FileName(), config.getUser());
            } else if (config.getServiceAccountKey() != null && !config.getServiceAccountKey().isBlank()) {
                client = getClientFactory().makeClient(getCamelContext(), config.getServiceAccountKey(),
                        config.getScopesAsList(),
                        config.getApplicationName(), config.getDelegate());
            } else {
                throw new IllegalArgumentException(
                        "(clientId and clientSecret) or serviceAccountKey are required to create Google Calendar client");
            }
        }
        return client;
    }

    protected void configureOutput(XsltBuilder xslt, String output) throws Exception {
        if (ObjectHelper.isEmpty(output)) {
            return;
        }

        if ("string".equalsIgnoreCase(output)) {
            xslt.outputString();
        } else if ("bytes".equalsIgnoreCase(output)) {
            xslt.outputBytes();
        } else if ("DOM".equalsIgnoreCase(output)) {
            xslt.outputDOM();
        } else if ("file".equalsIgnoreCase(output)) {
            xslt.outputFile();
        } else {
            throw new IllegalArgumentException("Unknown output type: " + output);
        }
    }

    public void doStop() throws Exception {
        if (ObjectHelper.isEmpty(configuration.getAmazonKinesisClient())) {
            if (kinesisClient != null) {
                kinesisClient.close();
            } else if (Objects.nonNull(kinesisAsyncClient)) {
                kinesisAsyncClient.close();
            }
        }
        if (!configuration.isCborEnabled()) {
            System.clearProperty(CBOR_ENABLED.property());
        }
        super.doStop();
    }

    private CopyArchiveFromContainerCmd executeCopyFileContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Copy File/Folder Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);
        String resource = DockerHelper.getProperty(DockerConstants.DOCKER_RESOURCE, configuration, message, String.class);

        if (containerId == null || resource == null) {
            throw new IllegalArgumentException("Container ID and Resource must be specified");
        }

        CopyArchiveFromContainerCmd copyArchiveFromContainerCmd = client.copyArchiveFromContainerCmd(containerId, resource);

        String hostPath = DockerHelper.getProperty(DockerConstants.DOCKER_HOST_PATH, configuration, message, String.class);

        if (hostPath != null) {
            copyArchiveFromContainerCmd.withHostPath(hostPath);
        }

        return copyArchiveFromContainerCmd;

    }

    public Future<Exchange> asyncSend() {
        DefaultFluentProducerTemplate clone = checkCloned();

         
        final Endpoint target = clone.target();

        Future<Exchange> result;
        Exchange exchange = clone.exchangeSupplier != null ? clone.exchangeSupplier.get() : null;
        if (exchange != null) {
            result = clone.template().asyncSend(target, exchange);
        } else {
            Processor proc = clone.processorSupplier != null ? clone.processorSupplier.get() : null;
            final Processor processor = proc != null ? proc : clone.defaultAsyncProcessor();
            result = clone.template().asyncSend(target, processor);
        }

         
        cloned = false;
        useDefaultEndpoint = true;

        return result;
    }

    public static HealthCheck getHealthCheck(CamelContext context, String id) {
        HealthCheck answer = null;

        HealthCheckRegistry hcr = context.getCamelContextExtension().getContextPlugin(HealthCheckRegistry.class);
        if (hcr != null && hcr.isEnabled()) {
            Optional<HealthCheck> check = hcr.getCheck(id);
            if (check.isEmpty()) {
                 
                HealthCheckResolver resolver
                        = context.getCamelContextExtension().getContextPlugin(HealthCheckResolver.class);
                HealthCheck hc = resolver.resolveHealthCheck(id);
                if (hc != null) {
                    check = Optional.of(hc);
                    hcr.register(hc);
                }
            }
            if (check.isPresent()) {
                answer = check.get();
            }
        }
        return answer;
    }

    protected void doFind(
            String packageName,
            ClassLoader classLoader,
            Set<Resource> resources,
            String subPattern,
            Predicate<String> filter) {

        Enumeration<URL> urls = getUrls(packageName, classLoader);
        if (urls == null) {
            return;
        }

        while (urls.hasMoreElements()) {
            URL url = null;
            try {
                url = urls.nextElement();
                LOG.trace("URL from classloader: {}", url);

                url = customResourceLocator(url);

                String urlPath = parseUrlPath(url);
                if (urlPath == null) {
                    continue;
                }

                LOG.trace("Scanning for resources in: {} matching pattern: {}", urlPath, subPattern);

                File file = new File(urlPath);
                if (file.isDirectory()) {
                    LOG.trace("Loading from directory using file: {}", file);
                    loadImplementationsInDirectory(subPattern, packageName, file, resources, filter);
                } else {
                    InputStream stream;
                    if (urlPath.startsWith("http:") || urlPath.startsWith("https:")
                            || urlPath.startsWith("sonicfs:")
                            || isAcceptableScheme(urlPath)) {
                         
                         
                        LOG.trace("Loading from jar using url: {}", urlPath);
                        URL urlStream = URI.create(urlPath).toURL();
                        URLConnection con = urlStream.openConnection();
                         
                        con.setUseCaches(false);
                        stream = con.getInputStream();
                    } else {
                        LOG.trace("Loading from jar using file: {}", file);
                        stream = new FileInputStream(file);
                    }
                    loadImplementationsInJar(url, packageName, subPattern, stream, urlPath, resources, filter);
                }
            } catch (IOException e) {
                 
                LOG.debug("Cannot read entries in url: {}", url, e);
            }
        }
    }

    public String parseCode() {
        try {
            parseTokens();
            return doParseCode();
        } catch (SimpleParserException e) {
             
            throw new SimpleIllegalSyntaxException(expression, e.getIndex(), e.getMessage(), e);
        } catch (Exception e) {
             
            throw new SimpleIllegalSyntaxException(expression, -1, e.getMessage(), e);
        }
    }

    protected void doStart() throws Exception {
        super.doStart();
        String token = System.getenv(CAMEL_HASHICORP_VAULT_TOKEN_ENV);
        String host = System.getenv(CAMEL_HASHICORP_VAULT_HOST_ENV);
        String port = System.getenv(CAMEL_HASHICORP_VAULT_PORT_ENV);
        String scheme = System.getenv(CAMEL_HASHICORP_VAULT_SCHEME_ENV);
        if (System.getenv(CAMEL_HASHICORP_VAULT_CLOUD_ENV) != null) {
            cloud = Boolean.parseBoolean(System.getenv(CAMEL_HASHICORP_VAULT_CLOUD_ENV));
        }
        namespace = System.getenv(CAMEL_HASHICORP_VAULT_NAMESPACE_ENV);
        if (ObjectHelper.isEmpty(token) && ObjectHelper.isEmpty(host)
                && ObjectHelper.isEmpty(port) && ObjectHelper.isEmpty(scheme) && ObjectHelper.isEmpty(namespace)) {
            HashicorpVaultConfiguration hashicorpVaultConfiguration = getCamelContext().getVaultConfiguration().hashicorp();
            if (ObjectHelper.isNotEmpty(hashicorpVaultConfiguration)) {
                token = hashicorpVaultConfiguration.getToken();
                host = hashicorpVaultConfiguration.getHost();
                port = hashicorpVaultConfiguration.getPort();
                scheme = hashicorpVaultConfiguration.getScheme();
                cloud = hashicorpVaultConfiguration.isCloud();
                if (hashicorpVaultConfiguration.isCloud()) {
                    namespace = hashicorpVaultConfiguration.getNamespace();
                }
            }
        }
        if (ObjectHelper.isNotEmpty(token) && ObjectHelper.isNotEmpty(host)
                && ObjectHelper.isNotEmpty(port) && ObjectHelper.isNotEmpty(scheme)) {
            VaultEndpoint vaultEndpoint = new VaultEndpoint();
            vaultEndpoint.setHost(host);
            vaultEndpoint.setPort(Integer.parseInt(port));
            vaultEndpoint.setScheme(scheme);

            client = new VaultTemplate(
                    vaultEndpoint,
                    new TokenAuthentication(token));
        } else {
            throw new RuntimeCamelException(
                    "Using the Hashicorp Properties Function requires setting Token, Host, port and scheme properties");
        }
    }

    private void generateEndpointConfigurer(
            Class<?> classElement, UriEndpoint uriEndpoint, String scheme, String[] schemes,
            ComponentModel componentModel, ComponentModel parentData) {
        if (!uriEndpoint.generateConfigurer()) {
            return;
        }
         
        if (isFirstScheme(scheme, schemes)) {
            return;
        }

        Class<?> superClazz = loadClass(componentModel.getJavaType()).getSuperclass();

        String pfqn;
        boolean hasSuper;
        if (parentData != null && superClazz.getName().equals(parentData.getJavaType())) {
            try {
                pfqn = classElement.getSuperclass().getName() + "Configurer";
                hasSuper = true;
            } catch (NoClassDefFoundError e) {
                pfqn = "org.apache.camel.support.component.PropertyConfigurerSupport";
                hasSuper = false;
                parentData = null;
            }
        } else {
            pfqn = "org.apache.camel.support.component.PropertyConfigurerSupport";
            hasSuper = false;
        }
        String psn = pfqn.substring(pfqn.lastIndexOf('.') + 1);
        String fqEndpointClassName = classElement.getName();
        String endpointClassName = fqEndpointClassName.substring(fqEndpointClassName.lastIndexOf('.') + 1);
        String className = endpointClassName + "Configurer";
        String packageName = fqEndpointClassName.substring(0, fqEndpointClassName.lastIndexOf('.'));
        String fqClassName = packageName + "." + className;

        List<EndpointOptionModel> options;
        if (parentData != null) {
            Set<String> parentOptionsNames = parentData.getEndpointParameterOptions().stream()
                    .map(EndpointOptionModel::getName).collect(Collectors.toSet());
            options = componentModel.getEndpointParameterOptions().stream()
                    .filter(o -> !parentOptionsNames.contains(o.getName()))
                    .toList();
        } else {
            options = componentModel.getEndpointParameterOptions();
        }
        generatePropertyConfigurer(packageName, className, fqClassName, endpointClassName,
                pfqn, psn,
                componentModel.getScheme() + "-endpoint", hasSuper, false,
                options, componentModel);
    }

    protected void doShutdown() throws Exception {
        ServiceHelper.stopAndShutdownService(map);

        if (scheduledExecutorService != null && stopScheduledExecutorService) {
            camelContext.getExecutorServiceManager().shutdown(scheduledExecutorService);
            scheduledExecutorService = null;
        }
        if (workerPool != null && stopWorkerPool) {
            camelContext.getExecutorServiceManager().shutdown(workerPool);
            workerPool = null;
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.aws.kinesis.getRecords");

        if (message.getHeaders().containsKey(Kinesis2Constants.PARTITION_KEY)) {
            headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SOURCE,
                    "aws.kinesis.partition.key." + message.getHeader(Kinesis2Constants.PARTITION_KEY, String.class));
        }

        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(Kinesis2Constants.SHARD_ID, String.class));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvent.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvent.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    private static String doGetHost(RestConfiguration config) throws UnknownHostException {
        String host = config.getHost();
        if (ObjectHelper.isEmpty(host)) {
            if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.allLocalIp) {
                host = "0.0.0.0";
            } else if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.localHostName) {
                host = HostUtils.getLocalHostName();
            } else if (config.getHostNameResolver() == RestConfiguration.RestHostNameResolver.localIp) {
                host = HostUtils.getLocalIp();
            }
        }
        return host;
    }

        private void initAdditionalCounters() {
            if (configuration.isExchangesSucceeded()) {
                this.exchangesSucceeded = createCounter(namingStrategy.getExchangesSucceededName(route),
                        "Number of successfully completed exchanges");
            }
            if (configuration.isExchangesFailed()) {
                this.exchangesFailed
                        = createCounter(namingStrategy.getExchangesFailedName(route), "Number of failed exchanges");
            }
            if (configuration.isExchangesTotal()) {
                this.exchangesTotal
                        = createCounter(namingStrategy.getExchangesTotalName(route), "Total number of processed exchanges");
            }
            if (configuration.isExternalRedeliveries()) {
                this.externalRedeliveries = createCounter(namingStrategy.getExternalRedeliveriesName(route),
                        "Number of external initiated redeliveries (such as from JMS broker)");
            }
            if (configuration.isFailuresHandled()) {
                this.failuresHandled
                        = createCounter(namingStrategy.getFailuresHandledName(route), "Number of failures handled");
            }
            if (configuration.isLongTask()) {
                LongTaskTimer.Builder builder = LongTaskTimer.builder(namingStrategy.getLongTaskName(route))
                        .tags(route != null ? namingStrategy.getTags(route) : namingStrategy.getTags(camelContext))
                        .description(route != null ? "Route long task metric" : "CamelContext long task metric");
                if (configuration.getLongTaskInitiator() != null) {
                    configuration.getLongTaskInitiator().accept(builder);
                }
                longTaskTimer = builder.register(meterRegistry);
            }
        }

    public void configureAuthentication(
            AuthenticationConfig authenticationConfig,
            HttpManagementServerConfigurationProperties properties) {

        String path
                = isNotEmpty(properties.getAuthenticationPath()) ? properties.getAuthenticationPath() : properties.getPath();
         
        if ("/".equals(path)) {
            path = "/*";
        }
        String realm = properties.getAuthenticationRealm() != null ? properties.getAuthenticationRealm() : null;

        AuthenticationConfigEntry entry = new AuthenticationConfigEntry();
        entry.setPath(path);
        entry.setAuthenticationHandlerFactory(new AuthenticationHandlerFactory() {
            @Override
            public <T extends AuthenticationProvider> AuthenticationHandler createAuthenticationHandler(
                    T authenticationProvider) {
                JWTAuth authProvider = (JWTAuth) authenticationProvider;
                return JWTAuthHandler.create(authProvider, realm);
            }
        });
        entry.setAuthenticationProviderFactory(vertx -> JWTAuth.create(
                vertx,
                new JWTAuthOptions(
                        new JsonObject().put("keyStore", new JsonObject()
                                .put("type", properties.getJwtKeystoreType())
                                .put("path", properties.getJwtKeystorePath())
                                .put("password", properties.getJwtKeystorePassword())))));

        authenticationConfig.getEntries().add(entry);
        authenticationConfig.setEnabled(true);
    }

    protected void doInit() throws Exception {
        super.doInit();
        if (meter == null) {
            this.meter = CamelContextHelper.findSingleByType(getCamelContext(), Meter.class);
        }
        if (meter == null) {
             
            this.meter = GlobalOpenTelemetry.get().getMeter("camel");
        }
        if (meter == null) {
            throw new RuntimeCamelException("Could not find any OpenTelemetry meter!");
        }
    }

    protected void doStop() throws Exception {
        if (connection != null) {
            for (IrcChannel channel : getEndpoint().getConfiguration().getChannelList()) {
                LOG.debug("Parting: {}", channel);
                connection.doPart(channel.getName());
            }
            connection.removeIRCEventListener(listener);
        }
        super.doStop();
    }

    private void rebootInstances(Ec2Client ec2Client, Exchange exchange) throws InvalidPayloadException {
        Collection<String> instanceIds;
        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RebootInstancesRequest) {
                try {
                    LOG.trace("Rebooting instances with Ids [{}] ", ((RebootInstancesRequest) payload).instanceIds());
                    ec2Client.rebootInstances((RebootInstancesRequest) payload);
                } catch (AwsServiceException ase) {
                    LOG.trace("Reboot Instances command returned the error code {}", ase.awsErrorDetails().errorCode());
                    throw ase;
                }
            }
        } else {
            RebootInstancesRequest.Builder builder = RebootInstancesRequest.builder();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(AWS2EC2Constants.INSTANCES_IDS))) {
                instanceIds = exchange.getIn().getHeader(AWS2EC2Constants.INSTANCES_IDS, Collection.class);
                builder.instanceIds(instanceIds);
            } else {
                throw new IllegalArgumentException(MISSING_INSTANCES_MESSAGE);
            }
            try {
                if (LOG.isTraceEnabled()) {
                    LOG.trace("Rebooting instances with Ids [{}] ", Arrays.toString(instanceIds.toArray()));
                }

                ec2Client.rebootInstances(builder.build());
            } catch (AwsServiceException ase) {
                LOG.trace("Reboot Instances command returned the error code {}", ase.awsErrorDetails().errorCode());
                throw ase;
            }
        }
    }

    private Queue<Exchange> pollAdminEvents() throws Exception {
        Keycloak keycloakClient = getEndpoint().getKeycloakClient();
        KeycloakConfiguration config = getEndpoint().getConfiguration();
        String realm = config.getRealm();

        if (realm == null) {
            throw new IllegalArgumentException("Realm must be specified for consuming admin events");
        }

         
         
         
        List<String> adminOperationTypes = parseCommaSeparatedList(config.getOperationTypes());
        List<AdminEventRepresentation> adminEvents = keycloakClient.realm(realm).getAdminEvents(
                adminOperationTypes,  
                config.getAuthRealmFilter(),  
                config.getAuthClient(),  
                config.getAuthUser(),  
                config.getAuthIpAddress(),  
                config.getResourcePath(),  
                config.getDateFrom(),  
                config.getDateTo(),  
                config.getFirst(),  
                config.getMaxResults()  
        );

        Queue<Exchange> queue = new LinkedList<>();
        long highestEventTime = lastEventTime != null ? lastEventTime : 0;

        for (AdminEventRepresentation adminEvent : adminEvents) {
            long eventTime = adminEvent.getTime();

             
            if (lastEventTime != null && eventTime < lastEventTime) {
                continue;
            }

             
            String fingerprint = getAdminEventFingerprint(adminEvent);

             
            if (processedEventFingerprints.contains(fingerprint)) {
                LOG.trace("Skipping already processed admin event: {}", fingerprint);
                continue;
            }

            Exchange exchange = createExchange(false);
            exchange.getIn().setBody(adminEvent);
            exchange.getIn().setHeader(KeycloakConstants.EVENT_TYPE, "admin-event");
            exchange.getIn().setHeader(KeycloakConstants.EVENT_ID, adminEvent.getTime());
            exchange.getIn().setHeader(KeycloakConstants.REALM_NAME, realm);
            queue.add(exchange);

             
            processedEventFingerprints.add(fingerprint);

             
            if (eventTime > highestEventTime) {
                highestEventTime = eventTime;
            }

             
            if (processedEventFingerprints.size() > MAX_FINGERPRINT_CACHE_SIZE) {
                 
                 
                processedEventFingerprints.clear();
                LOG.debug("Cleared fingerprint cache due to size limit");
            }
        }

         
        if (highestEventTime > (lastEventTime != null ? lastEventTime : 0)) {
             
            processedEventFingerprints.clear();
            lastEventTime = highestEventTime;
            LOG.debug("Updated last admin event time to: {}", lastEventTime);
        }

        return queue;
    }

    private void updateClientRole(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        String roleName = exchange.getIn().getHeader(KeycloakConstants.ROLE_NAME, String.class);
        if (ObjectHelper.isEmpty(roleName)) {
            throw new IllegalArgumentException(MISSING_ROLE_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof RoleRepresentation) {
                keycloakClient.realm(realmName).clients().get(clientUuid).roles().get(roleName)
                        .update((RoleRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Client role updated successfully");
            }
        } else {
            throw new IllegalArgumentException("Update client role requires POJO request with RoleRepresentation");
        }
    }

    public Olingo4AppWrapper createApiProxy(Olingo4Configuration endpointConfiguration) {
        final Olingo4AppWrapper result;
        if (endpointConfiguration.equals(getConfiguration())) {
            lock.lock();
            try {
                if (apiProxy == null) {
                    apiProxy = createOlingo4App(getConfiguration());
                }
            } finally {
                lock.unlock();
            }
            result = apiProxy;
        } else {
            result = createOlingo4App(endpointConfiguration);
        }
        return result;
    }

    public <T> T newInstance(Class<T> type, Class<?> factoryClass, String factoryMethod) {
        Class<?> target = factoryClass != null ? factoryClass : type;
        T answer = null;
        try {
             
            Method fm = target.getMethod(factoryMethod);
            if (Modifier.isStatic(fm.getModifiers()) && Modifier.isPublic(fm.getModifiers())
                    && fm.getReturnType() != Void.class) {
                Object obj = fm.invoke(null);
                answer = type.cast(obj);
            }
        } catch (Exception e) {
            throw new RuntimeCamelException("Error invoking factory method: " + factoryMethod + " on class: " + target, e);
        }
        return answer;
    }

    public Edm getEdm(Map<String, String> endpointHttpHeaders) throws RuntimeCamelException {
        Edm localEdm = edm;
        if (localEdm == null) {
            lock.lock();
            try {

                localEdm = edm;
                if (localEdm == null) {

                    final CountDownLatch latch = new CountDownLatch(1);
                    final Exception[] error = new Exception[1];
                    olingo4App.read(null, Constants.METADATA, null, endpointHttpHeaders, new Olingo4ResponseHandler<Edm>() {

                        @Override
                        public void onResponse(Edm response, Map<String, String> responseHeaders) {
                            edm = response;
                            latch.countDown();
                        }

                        @Override
                        public void onException(Exception ex) {
                            error[0] = ex;
                            latch.countDown();
                        }

                        @Override
                        public void onCanceled() {
                            error[0] = new RuntimeCamelException("OData HTTP request cancelled!");
                            latch.countDown();
                        }
                    });

                    try {
                         
                        latch.await();

                        final Exception ex = error[0];
                        if (ex != null) {
                            if (ex instanceof RuntimeCamelException) {
                                throw (RuntimeCamelException) ex;
                            } else {
                                final String message = ex.getMessage() != null ? ex.getMessage() : ex.getClass().getName();
                                throw new RuntimeCamelException("Error reading EDM: " + message, ex);
                            }
                        }

                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        throw new RuntimeCamelException(e.getMessage(), e);
                    }

                    localEdm = edm;
                }
            } finally {
                lock.unlock();
            }
        }

        return localEdm;
    }

    protected List<Configurer<SSLSocketFactory>> getSSLSocketFactoryConfigurers(SSLContext context) {

        final List<Configurer<SSLSocket>> sslSocketConfigurers = this.getSSLSocketFactorySSLSocketConfigurers(context);

        Configurer<SSLSocketFactory> sslSocketFactoryConfigurer = new Configurer<>() {

            @Override
            public SSLSocketFactory configure(SSLSocketFactory factory) {
                return new SSLSocketFactoryDecorator(
                        factory,
                        sslSocketConfigurers);
            }
        };

        List<Configurer<SSLSocketFactory>> sslSocketFactoryConfigurers = new LinkedList<>();
        sslSocketFactoryConfigurers.add(sslSocketFactoryConfigurer);

        return sslSocketFactoryConfigurers;
    }

    public boolean process(final Exchange exchange, final AsyncCallback callback) {
         
        final Map<String, Object> properties = new HashMap<>(endpoint.getEndpointProperties());
        propertiesHelper.getExchangeProperties(exchange, properties);

         
        endpoint.interceptProperties(properties);
        interceptProperties(properties);

         
        properties.put(Olingo4Endpoint.RESPONSE_HANDLER_PROPERTY, new Olingo4ResponseHandler<Object>() {
            @Override
            public void onResponse(Object response, Map<String, String> responseHeaders) {
                if (resultIndex != null) {
                    response = resultIndex.filterResponse(response);
                }

                 
                 
                exchange.getOut().setBody(response);
                 
                exchange.getOut().setHeaders(exchange.getIn().getHeaders());

                 
                exchange.getOut().setHeader(Olingo4Constants.FULL_RESPONSE_HTTP_HEADERS, responseHeaders);

                interceptResult(response, exchange);

                callback.done(false);
            }

            @Override
            public void onException(Exception ex) {
                exchange.setException(ex);
                callback.done(false);
            }

            @Override
            public void onCanceled() {
                exchange.setException(new RuntimeCamelException("OData HTTP Request cancelled!"));
                callback.done(false);
            }
        });

         
        final ApiMethod method = findMethod(exchange, properties);
        if (method == null) {
             
            callback.done(true);
            return true;
        }

        if (LOG.isDebugEnabled()) {
            LOG.debug("Invoking operation {} with {}", method.getName(), properties.keySet());
        }

        try {
            doInvokeMethod(method, properties);
        } catch (Exception e) {
            exchange.setException(RuntimeCamelException.wrapRuntimeCamelException(e));
            callback.done(true);
            return true;
        }
        return false;

    }

    public String dumpRoutesStatsAsXml(boolean fullStats, boolean includeProcessors) throws Exception {
        StringBuilder sb = new StringBuilder();
        sb.append("<camelContextStat")
                .append(String.format(" id=\"%s\" state=\"%s\" uptime=\"%s\"", getCamelId(), getState(), getUptimeMillis()));
         
        String stat = dumpStatsAsXml(fullStats);
        sb.append(" exchangesInflight=\"").append(getInflightExchanges()).append("\"");
        sb.append(" ").append(stat, 7, stat.length() - 2).append(">\n");

        MBeanServer server = getContext().getManagementStrategy().getManagementAgent().getMBeanServer();
        if (server != null) {
             
            String prefix = getContext().getManagementStrategy().getManagementAgent().getIncludeHostName() ? "*/" : "";
            ObjectName query = ObjectName
                    .getInstance(jmxDomain + ":context=" + prefix + getContext().getManagementName() + ",type=routes,*");
            Set<ObjectName> routes = server.queryNames(query, null);

            List<ManagedProcessorMBean> processors = new ArrayList<>();
            if (includeProcessors) {
                 
                query = ObjectName.getInstance(
                        jmxDomain + ":context=" + prefix + getContext().getManagementName() + ",type=processors,*");
                Set<ObjectName> names = server.queryNames(query, null);
                for (ObjectName on : names) {
                    ManagedProcessorMBean processor = context.getManagementStrategy().getManagementAgent().newProxyClient(on,
                            ManagedProcessorMBean.class);
                    processors.add(processor);
                }
            }
            processors.sort(new OrderProcessorMBeans());

             
            sb.append("  <routeStats>\n");
            for (ObjectName on : routes) {
                ManagedRouteMBean route
                        = context.getManagementStrategy().getManagementAgent().newProxyClient(on, ManagedRouteMBean.class);
                sb.append("    <routeStat")
                        .append(String.format(" id=\"%s\" state=\"%s\" uptime=\"%s\"", route.getRouteId(), route.getState(),
                                route.getUptimeMillis()));
                if (route.getRouteGroup() != null) {
                    sb.append(String.format(" group=\"%s\"", route.getRouteGroup()));
                }
                if (route.getSourceLocation() != null) {
                    sb.append(String.format(" sourceLocation=\"%s\"", route.getSourceLocation()));
                }

                 
                stat = route.dumpStatsAsXml(fullStats);
                sb.append(" exchangesInflight=\"").append(route.getExchangesInflight()).append("\"");
                sb.append(" ").append(stat, 7, stat.length() - 2).append(">\n");

                 
                if (includeProcessors) {
                    sb.append("      <processorStats>\n");
                    for (ManagedProcessorMBean processor : processors) {
                        int line = processor.getSourceLineNumber() != null ? processor.getSourceLineNumber() : -1;
                         
                        if (route.getRouteId().equals(processor.getRouteId())) {
                            sb.append("        <processorStat")
                                    .append(String.format(
                                            " id=\"%s\" index=\"%s\" state=\"%s\" disabled=\"%s\" sourceLineNumber=\"%s\"",
                                            processor.getProcessorId(), processor.getIndex(), processor.getState(),
                                            processor.getDisabled(), line));
                             
                            stat = processor.dumpStatsAsXml(fullStats);
                            sb.append(" exchangesInflight=\"").append(processor.getExchangesInflight()).append("\"");
                            sb.append(" ").append(stat, 7, stat.length()).append("\n");
                        }
                    }
                    sb.append("      </processorStats>\n");
                }
                sb.append("    </routeStat>\n");
            }
            sb.append("  </routeStats>\n");
        }

        sb.append("</camelContextStat>");
        return sb.toString();
    }

    public static JsonObject asJsonObject(JBangModel model) {
        JsonObject json = new JsonObject();
        JsonArray groups = new JsonArray();
        for (JBangGroupModel group : model.getGroups()) {
            JsonObject j = new JsonObject();
            j.put("name", group.getName());
            if (group.getDescription() != null) {
                j.put("description", group.getDescription());
            }
            if (group.getSourceType() != null) {
                j.put("sourceType", group.getSourceType());
            }
            groups.add(j);
        }
        json.put("groups", groups);
        JsonArray props = new JsonArray();
        for (JBangOptionModel prop : model.getOptions()) {
            JsonObject j = new JsonObject();
            j.put("name", prop.getName());
            j.put("required", prop.isRequired());
            if (prop.getDescription() != null) {
                j.put("description", prop.getDescription());
            }
            if (prop.getGroup() != null) {
                j.put("group", prop.getGroup());
            }
            if (prop.getLabel() != null) {
                j.put("label", prop.getLabel());
            }
            if (prop.getSourceType() != null) {
                j.put("sourceType", prop.getSourceType());
            }
            j.put("type", prop.getType());
            j.put("javaType", prop.getJavaType());
            if (prop.getDefaultValue() != null) {
                j.put("defaultValue", prop.resolveDefaultValue());
            }
            j.put("secret", prop.isSecret());
            if (prop.getEnums() != null) {
                j.put("enum", prop.getEnums());
            }
            if (prop.isDeprecated()) {
                j.put("deprecated", prop.isDeprecated());
            }
            if (prop.isAutowired()) {
                j.put("autowired", prop.isAutowired());
            }
            props.add(j);
        }
        json.put("properties", props);
        return json;
    }

    private void listCustomModels(Exchange exchange) {
        SpeechToText stt = getEndpoint().getSttClient();
        if (stt == null) {
            throw new IllegalStateException("STT client not initialized");
        }

        String language = exchange.getIn().getHeader(WatsonSpeechToTextConstants.LANGUAGE, String.class);

        LOG.trace("Listing custom language models, language filter: {}", language);

        ListLanguageModelsOptions.Builder builder = new ListLanguageModelsOptions.Builder();
        if (language != null && !language.isBlank()) {
            builder.language(language);
        }

        ListLanguageModelsOptions options = builder.build();
        LanguageModels customModels = stt.listLanguageModels(options).execute().getResult();

        Message message = getMessageForResponse(exchange);
        List<LanguageModel> models = customModels.getCustomizations();
        message.setBody(models != null ? models : List.of());
    }

    private static String evaluateTemplate(final String templateName, final MainModel model) throws MojoExecutionException {
        StringBuilder sb = new StringBuilder(256);

        try (InputStream templateStream = UpdateReadmeMojo.class.getClassLoader().getResourceAsStream(templateName)) {
            String template = PackageHelper.loadText(templateStream);
             
            for (MainModel.MainGroupModel group : model.getGroups()) {
                Map<String, Object> root = new HashMap<>();
                root.put("group", group);
                root.put("options", model.getOptions().stream()
                        .filter(o -> o.getName().startsWith(group.getName()))
                        .toList());
                String eval
                        = (String) TemplateRuntime.eval(template, root, Collections.singletonMap("util", MvelHelper.INSTANCE));
                sb.append(eval);
                sb.append("\n");
            }
        } catch (IOException e) {
            throw new MojoExecutionException("Error processing mvel template `" + templateName + "`", e);
        }

        return sb.toString();
    }

    private void predictions(Exchange exchange) throws ApiException {
        Message message = exchange.getMessage();
        TorchServeConfiguration configuration = getEndpoint().getConfiguration();
        String modelName = Optional
                .ofNullable(message.getHeader(TorchServeConstants.MODEL_NAME, String.class))
                .orElse(configuration.getModelName());
        String modelVersion = Optional
                .ofNullable(message.getHeader(TorchServeConstants.MODEL_VERSION, String.class))
                .orElse(configuration.getModelVersion());
        Object body = message.getBody(byte[].class);
        Object response;
        if (modelVersion == null) {
            response = this.inference.predictions(modelName, body);
        } else {
            response = this.inference.predictions(modelName, modelVersion, body);
        }
        message.setBody(response);
    }

    public void search(String soslQuery, Map<String, List<String>> headers, ResponseCallback callback) {
        try {

            String encodedQuery = urlEncode(soslQuery);
            final Request get = getRequest(HttpMethod.GET, versionUrl() + "search/?q=" + encodedQuery, headers);

             
            setAccessToken(get);

            doHttpRequest(get, new DelegatingClientCallback(callback));

        } catch (UnsupportedEncodingException e) {
            String msg = "Unexpected error: " + e.getMessage();
            callback.onResponse(null, Collections.emptyMap(), new SalesforceException(msg, e));
        }
    }

    protected boolean acceptResource(Resource resource) {
        String loc = resource.getLocation();
        if (loc == null) {
            return false;
        }
        if (loc.endsWith("default-registry")) {
             
            return false;
        }

        return true;
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            stompEndpoint.send(exchange, callback);
            return false;
        } catch (Exception e) {
            exchange.setException(e);
        }
        callback.done(true);
        return true;
    }

    protected void doStart() throws Exception {
        StringHelper.notEmpty(mapName, "repositoryName");
        if (maximumRedeliveries < 0) {
            throw new IllegalArgumentException("Maximum redelivery retries must be zero or a positive integer.");
        }
        if (recoveryInterval < 0) {
            throw new IllegalArgumentException("Recovery interval must be zero or a positive integer.");
        }
        if (persistenceMapName == null) {
            persistenceMapName = String.format("%s%s", mapName, COMPLETED_SUFFIX);
        }
        if (hazelcastInstance == null) {
            useLocalHzInstance = true;
            Config cfg = new XmlConfigBuilder().build();
            cfg.setProperty("hazelcast.version.check.enabled", "false");
            hazelcastInstance = Hazelcast.newHazelcastInstance(cfg);
        } else {
            ObjectHelper.notNull(hazelcastInstance, "hazelcastInstance");
        }
        cache = hazelcastInstance.getMap(mapName);
        if (useRecovery) {
            persistedCache = hazelcastInstance.getMap(persistenceMapName);
        }
    }

    private String getSecretKey(ImageRecognitionEndpoint endpoint) {
        if (!StringUtils.isEmpty(endpoint.getSecretKey())) {
            return endpoint.getSecretKey();
        } else if (endpoint.getServiceKeys() != null
                && !StringUtils.isEmpty(endpoint.getServiceKeys().getSecretKey())) {
            return endpoint.getServiceKeys().getSecretKey();
        } else {
            throw new IllegalArgumentException("authentication parameter 'secret key (SK)' not found");
        }
    }

    private Consumer<CosmosContainerResponse> setCosmosContainerResponseOnExchange(final Exchange exchange) {
        return response -> {
            if (ObjectHelper.isNotEmpty(response.getProperties())) {
                setMessageHeader(exchange, CosmosDbConstants.RESOURCE_ID, response.getProperties().getResourceId());
                setMessageHeader(exchange, CosmosDbConstants.E_TAG, response.getProperties().getETag());
                setMessageHeader(exchange, CosmosDbConstants.TIMESTAMP, response.getProperties().getTimestamp());
                setMessageHeader(exchange, CosmosDbConstants.DEFAULT_TIME_TO_LIVE_SECONDS,
                        response.getProperties().getDefaultTimeToLiveInSeconds());
            }
            setCommonResponseOnExchange(exchange, response);
        };
    }

    private DocumentLocation createDocumentLocationFromExchange(Exchange exchange) {
        String s3Bucket = getConfiguration().getS3Bucket();
        String s3Object = getConfiguration().getS3Object();

        if (ObjectHelper.isEmpty(s3Bucket)) {
            s3Bucket = exchange.getIn().getHeader(Textract2Constants.S3_BUCKET, String.class);
        }
        if (ObjectHelper.isEmpty(s3Object)) {
            s3Object = exchange.getIn().getHeader(Textract2Constants.S3_OBJECT, String.class);
        }

        if (ObjectHelper.isEmpty(s3Bucket) || ObjectHelper.isEmpty(s3Object)) {
            throw new IllegalArgumentException("S3 bucket and object must be specified for async operations");
        }

        S3Object.Builder s3ObjectBuilder = S3Object.builder()
                .bucket(s3Bucket)
                .name(s3Object);

        String s3ObjectVersion = getConfiguration().getS3ObjectVersion();
        if (ObjectHelper.isEmpty(s3ObjectVersion)) {
            s3ObjectVersion = exchange.getIn().getHeader(Textract2Constants.S3_OBJECT_VERSION, String.class);
        }
        if (ObjectHelper.isNotEmpty(s3ObjectVersion)) {
            s3ObjectBuilder.version(s3ObjectVersion);
        }

        return DocumentLocation.builder()
                .s3Object(s3ObjectBuilder.build())
                .build();
    }

    public Integer doCall() throws Exception {
        List<Row> rows = new ArrayList<>();

        List<Long> pids = findPids(name);
        if (pids.isEmpty()) {
            return 0;
        } else if (pids.size() > 1) {
            printer().println("Name or pid " + name + " matches " + pids.size()
                              + " running Camel integrations. Specify a name or PID that matches exactly one.");
            return 0;
        }

        this.pid = pids.get(0);

         
        Path outputFile = getOutputFile(Long.toString(pid));
        PathUtils.deleteFile(outputFile);

        JsonObject root = new JsonObject();
        root.put("action", "route-dump");
        root.put("filter", "*");
        root.put("format", format);
        root.put("uriAsParameters", uriAsParameters);
        Path file = getActionFile(Long.toString(pid));
        try {
            Files.writeString(file, root.toJson());
        } catch (Exception e) {
             
        }

        JsonObject jo = waitForOutputFile(outputFile);
        if (jo != null) {
            JsonArray arr = (JsonArray) jo.get("routes");
            for (int i = 0; i < arr.size(); i++) {
                JsonObject o = (JsonObject) arr.get(i);
                Row row = new Row();
                row.location = extractSourceName(o.getString("source"));
                row.routeId = o.getString("routeId");
                if (!rows.contains(row)) {
                    List<JsonObject> lines = o.getCollection("code");
                    if (lines != null) {
                        for (JsonObject line : lines) {
                            Code code = new Code();
                            code.line = line.getInteger("line");
                            code.code = line.getString("code");
                            row.code.add(code);
                        }
                    }
                    boolean add = true;
                    if (filter != null) {
                        String f = filter;
                        boolean negate = filter.startsWith("-");
                        if (negate) {
                            f = f.substring(1);
                        }
                         
                        if (!f.endsWith("*")) {
                            f += "*";
                        }
                        boolean match
                                = PatternHelper.matchPattern(row.location, f) || PatternHelper.matchPattern(row.routeId, f);
                        if (negate) {
                            match = !match;
                        }
                        if (!match) {
                            add = false;
                        }
                    }
                    if (add) {
                        rows.add(row);
                    }
                }
            }
        } else {
            printer().println("Response from running Camel with PID " + pid + " not received within 5 seconds");
            return 1;
        }

         
        rows.sort(this::sortRow);

        if (!rows.isEmpty()) {
            printSource(rows);
        }

         
        PathUtils.deleteFile(outputFile);

        return 0;
    }

    protected Object doInvokeMethod(Map<String, Object> properties) throws RuntimeCamelException {
        AbstractGoogleClientRequest<?> request = (AbstractGoogleClientRequest) super.doInvokeMethod(properties);
        try {
            BeanIntrospection beanIntrospection
                    = PluginHelper.getBeanIntrospection(getEndpoint().getCamelContext());
            for (Entry<String, Object> p : properties.entrySet()) {
                beanIntrospection.setProperty(getEndpoint().getCamelContext(), request, p.getKey(), p.getValue());
            }
            return request.execute();
        } catch (Exception e) {
            throw new RuntimeCamelException(e);
        }
    }

        private BiPredicate<String, Component> condition() {
            if (type.equals(Component.class)) {
                return this.condition != null
                        ? this.condition
                        : new BiPredicate<>() {
                            @Override
                            public boolean test(String s, Component language) {
                                return true;
                            }
                        };
            }

            if (condition == null) {
                return new BiPredicate<>() {
                    @Override
                    public boolean test(String name, Component target) {
                        return type.isAssignableFrom(target.getClass());
                    }
                };
            }

            return new BiPredicate<>() {
                @Override
                public boolean test(String name, Component target) {
                    return type.isAssignableFrom(target.getClass()) && condition.test(name, target);
                }
            };
        }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.google.pubsub.pull");

        if (message.getHeaders().containsKey(GooglePubsubConstants.ACK_ID)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "google.pubsub." + message.getHeader(GooglePubsubConstants.ACK_ID, String.class));
        }

        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT, message.getHeader(GooglePubsubConstants.MESSAGE_ID, String.class));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_CONTENT_TYPE, CloudEvents.APPLICATION_OCTET_STREAM_MIME_TYPE);
    }

    public static HttpMethods createMethod(Exchange exchange, HttpCommonEndpoint endpoint, boolean hasPayload)
            throws URISyntaxException {
         
        String queryString = exchange.getIn().getHeader(Exchange.HTTP_QUERY, String.class);
         
        String uriString = exchange.getIn().getHeader(Exchange.HTTP_URI, String.class);
         
        try {
            uriString = exchange.getContext().resolvePropertyPlaceholders(uriString);
        } catch (Exception e) {
            throw new RuntimeExchangeException("Cannot resolve property placeholders with uri: " + uriString, exchange, e);
        }
        if (uriString != null) {
             
            uriString = UnsafeUriCharactersEncoder.encodeHttpURI(uriString);
            URI uri = new URI(uriString);
            queryString = uri.getQuery();
        }
        if (queryString == null) {
            queryString = endpoint.getHttpUri().getRawQuery();
        }

        HttpMethods answer;
        if (endpoint.getHttpMethod() != null) {
             
            answer = endpoint.getHttpMethod();
        } else {
             
            HttpMethods m = exchange.getIn().getHeader(Exchange.HTTP_METHOD, HttpMethods.class);
            if (m != null) {
                 
                answer = m;
            } else if (queryString != null) {
                 
                answer = HttpMethods.GET;
            } else {
                 
                answer = hasPayload ? HttpMethods.POST : HttpMethods.GET;
            }
        }

        return answer;
    }

    public static EventHubConsumerAsyncClient createEventHubConsumerAsyncClient(final EventHubsConfiguration configuration) {
        EventHubClientBuilder eventHubClientBuilder = new EventHubClientBuilder()
                .consumerGroup(configuration.getConsumerGroupName())
                .prefetchCount(configuration.getPrefetchCount())
                .transportType(configuration.getAmqpTransportType())
                .retryOptions(configuration.getAmqpRetryOptions());

        CredentialType type = configuration.getCredentialType();
        if (type == null) {
            type = CredentialType.CONNECTION_STRING;
        }
        if (CredentialType.CONNECTION_STRING.equals(type)) {
            return eventHubClientBuilder
                    .connectionString(buildConnectionString(configuration))
                    .buildAsyncConsumerClient();
        } else if (CredentialType.TOKEN_CREDENTIAL.equals(type)) {

            checkTokenCredentialConfiguration(configuration);
            return eventHubClientBuilder
                    .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                    .eventHubName(configuration.getEventHubName())
                    .credential(configuration.getTokenCredential())
                    .buildAsyncConsumerClient();
        }
        return eventHubClientBuilder
                .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                .eventHubName(configuration.getEventHubName())
                .credential(new DefaultAzureCredentialBuilder().build())
                .buildAsyncConsumerClient();
    }

    public MilvusClient getClient() {
        if (this.client == null) {
            lock.lock();
            try {
                if (this.client == null) {
                    this.client = this.configuration.getClient();
                    this.closeClient = false;

                    if (this.client == null) {
                        this.client = createClient();
                        this.closeClient = true;
                    }
                }
            } finally {
                lock.unlock();
            }
        }

        return this.client;
    }

    protected void doStart() throws Exception {
        if (maximumRedeliveries < 0) {
            throw new IllegalArgumentException("Maximum redelivery retries must be zero or a positive integer.");
        }
        if (recoveryInterval < 0) {
            throw new IllegalArgumentException("Recovery interval must be zero or a positive integer.");
        }

        if (cache == null) {
            Caffeine<Object, Object> builder = Caffeine.newBuilder();
            cache = builder.build();
        }
    }

    private void createIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                Response response
                        = keycloakClient.realm(realmName).identityProviders().create((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException(
                    "Create identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    public void transform(Message message, DataType fromType, DataType toType) {
        final Map<String, Object> headers = message.getHeaders();

        CloudEvent cloudEvent = CloudEvents.v1_0;
        headers.putIfAbsent(CloudEvents.CAMEL_CLOUD_EVENT_ID, message.getExchange().getExchangeId());
        headers.putIfAbsent(CloudEvent.CAMEL_CLOUD_EVENT_VERSION, cloudEvent.version());
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TYPE, "org.apache.camel.event.google.storage.downloadTo");

        if (message.getHeaders().containsKey(GoogleCloudStorageConstants.BUCKET_NAME)) {
            headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SOURCE,
                    "google.storage.bucket." + message.getHeader(GoogleCloudStorageConstants.BUCKET_NAME, String.class));
        }

        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_SUBJECT,
                message.getHeader(GoogleCloudStorageConstants.OBJECT_NAME, String.class));
        headers.put(CloudEvents.CAMEL_CLOUD_EVENT_TIME, cloudEvent.getEventTime(message.getExchange()));
    }

    public static XQueryBuilder xquery(final InputStream in) {
        return new XQueryBuilder() {
            protected XQueryExpression createQueryExpression(StaticQueryContext staticQueryContext)
                    throws XPathException {
                try {
                    return staticQueryContext.compileQuery(in, ObjectHelper.getDefaultCharacterSet());
                } finally {
                    IOHelper.close(in);
                }
            }
        };
    }

        protected boolean setPropertyOnComponent(
                Component component,
                String name,
                Object value) {
            switch (name) {
            case "additionalProperties": getOrCreateConfiguration((DebeziumMongodbComponent) component).setAdditionalProperties((java.util.Map) value); return true;
            case "bridgeErrorHandler": ((DebeziumMongodbComponent) component).setBridgeErrorHandler((boolean) value); return true;
            case "configuration": ((DebeziumMongodbComponent) component).setConfiguration((org.apache.camel.component.debezium.mongodb.configuration.MongoDbConnectorEmbeddedDebeziumConfiguration) value); return true;
            case "internalKeyConverter": getOrCreateConfiguration((DebeziumMongodbComponent) component).setInternalKeyConverter((java.lang.String) value); return true;
            case "internalValueConverter": getOrCreateConfiguration((DebeziumMongodbComponent) component).setInternalValueConverter((java.lang.String) value); return true;
            case "offsetCommitPolicy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetCommitPolicy((java.lang.String) value); return true;
            case "offsetCommitTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetCommitTimeoutMs((long) value); return true;
            case "offsetFlushIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetFlushIntervalMs((long) value); return true;
            case "offsetStorage": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorage((java.lang.String) value); return true;
            case "offsetStorageFileName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageFileName((java.lang.String) value); return true;
            case "offsetStoragePartitions": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStoragePartitions((int) value); return true;
            case "offsetStorageReplicationFactor": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageReplicationFactor((int) value); return true;
            case "offsetStorageTopic": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOffsetStorageTopic((java.lang.String) value); return true;
            case "autowiredEnabled": ((DebeziumMongodbComponent) component).setAutowiredEnabled((boolean) value); return true;
            case "captureMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCaptureMode((java.lang.String) value); return true;
            case "collectionExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCollectionExcludeList((java.lang.String) value); return true;
            case "collectionIncludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCollectionIncludeList((java.lang.String) value); return true;
            case "connectionValidationTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setConnectionValidationTimeoutMs((long) value); return true;
            case "converters": getOrCreateConfiguration((DebeziumMongodbComponent) component).setConverters((java.lang.String) value); return true;
            case "cursorMaxAwaitTimeMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCursorMaxAwaitTimeMs((int) value); return true;
            case "customMetricTags": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCustomMetricTags((java.lang.String) value); return true;
            case "customSanitizePattern": getOrCreateConfiguration((DebeziumMongodbComponent) component).setCustomSanitizePattern((java.lang.String) value); return true;
            case "databaseExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setDatabaseExcludeList((java.lang.String) value); return true;
            case "databaseIncludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setDatabaseIncludeList((java.lang.String) value); return true;
            case "errorsMaxRetries": getOrCreateConfiguration((DebeziumMongodbComponent) component).setErrorsMaxRetries((int) value); return true;
            case "eventProcessingFailureHandlingMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setEventProcessingFailureHandlingMode((java.lang.String) value); return true;
            case "executorShutdownTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setExecutorShutdownTimeoutMs((long) value); return true;
            case "extendedHeadersEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setExtendedHeadersEnabled((boolean) value); return true;
            case "fieldExcludeList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setFieldExcludeList((java.lang.String) value); return true;
            case "fieldRenames": getOrCreateConfiguration((DebeziumMongodbComponent) component).setFieldRenames((java.lang.String) value); return true;
            case "guardrailCollectionsLimitAction": getOrCreateConfiguration((DebeziumMongodbComponent) component).setGuardrailCollectionsLimitAction((java.lang.String) value); return true;
            case "guardrailCollectionsMax": getOrCreateConfiguration((DebeziumMongodbComponent) component).setGuardrailCollectionsMax((int) value); return true;
            case "heartbeatIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setHeartbeatIntervalMs((int) value); return true;
            case "heartbeatTopicsPrefix": getOrCreateConfiguration((DebeziumMongodbComponent) component).setHeartbeatTopicsPrefix((java.lang.String) value); return true;
            case "incrementalSnapshotWatermarkingStrategy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setIncrementalSnapshotWatermarkingStrategy((java.lang.String) value); return true;
            case "maxBatchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxBatchSize((int) value); return true;
            case "maxQueueSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxQueueSize((int) value); return true;
            case "maxQueueSizeInBytes": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMaxQueueSizeInBytes((long) value); return true;
            case "mongodbAuthsource": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbAuthsource((java.lang.String) value); return true;
            case "mongodbConnectionString": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbConnectionString((java.lang.String) value); return true;
            case "mongodbConnectTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbConnectTimeoutMs((int) value); return true;
            case "mongodbHeartbeatFrequencyMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbHeartbeatFrequencyMs((int) value); return true;
            case "mongodbPassword": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbPassword((java.lang.String) value); return true;
            case "mongodbPollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbPollIntervalMs((long) value); return true;
            case "mongodbServerSelectionTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbServerSelectionTimeoutMs((int) value); return true;
            case "mongodbSocketTimeoutMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSocketTimeoutMs((int) value); return true;
            case "mongodbSslEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSslEnabled((boolean) value); return true;
            case "mongodbSslInvalidHostnameAllowed": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbSslInvalidHostnameAllowed((boolean) value); return true;
            case "mongodbUser": getOrCreateConfiguration((DebeziumMongodbComponent) component).setMongodbUser((java.lang.String) value); return true;
            case "notificationEnabledChannels": getOrCreateConfiguration((DebeziumMongodbComponent) component).setNotificationEnabledChannels((java.lang.String) value); return true;
            case "notificationSinkTopicName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setNotificationSinkTopicName((java.lang.String) value); return true;
            case "openlineageIntegrationConfigFilePath": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationConfigFilePath((java.lang.String) value); return true;
            case "openlineageIntegrationDatasetKafkaBootstrapServers": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationDatasetKafkaBootstrapServers((java.lang.String) value); return true;
            case "openlineageIntegrationEnabled": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationEnabled((boolean) value); return true;
            case "openlineageIntegrationJobDescription": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobDescription((java.lang.String) value); return true;
            case "openlineageIntegrationJobNamespace": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobNamespace((java.lang.String) value); return true;
            case "openlineageIntegrationJobOwners": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobOwners((java.lang.String) value); return true;
            case "openlineageIntegrationJobTags": getOrCreateConfiguration((DebeziumMongodbComponent) component).setOpenlineageIntegrationJobTags((java.lang.String) value); return true;
            case "pollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setPollIntervalMs((long) value); return true;
            case "postProcessors": getOrCreateConfiguration((DebeziumMongodbComponent) component).setPostProcessors((java.lang.String) value); return true;
            case "provideTransactionMetadata": getOrCreateConfiguration((DebeziumMongodbComponent) component).setProvideTransactionMetadata((boolean) value); return true;
            case "queryFetchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setQueryFetchSize((int) value); return true;
            case "retriableRestartConnectorWaitMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setRetriableRestartConnectorWaitMs((long) value); return true;
            case "schemaHistoryInternalFileFilename": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSchemaHistoryInternalFileFilename((java.lang.String) value); return true;
            case "schemaNameAdjustmentMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSchemaNameAdjustmentMode((java.lang.String) value); return true;
            case "signalDataCollection": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalDataCollection((java.lang.String) value); return true;
            case "signalEnabledChannels": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalEnabledChannels((java.lang.String) value); return true;
            case "signalPollIntervalMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSignalPollIntervalMs((long) value); return true;
            case "skippedOperations": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSkippedOperations((java.lang.String) value); return true;
            case "snapshotCollectionFilterOverrides": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotCollectionFilterOverrides((java.lang.String) value); return true;
            case "snapshotDelayMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotDelayMs((long) value); return true;
            case "snapshotFetchSize": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotFetchSize((int) value); return true;
            case "snapshotIncludeCollectionList": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotIncludeCollectionList((java.lang.String) value); return true;
            case "snapshotMaxThreads": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotMaxThreads((int) value); return true;
            case "snapshotMode": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotMode((java.lang.String) value); return true;
            case "snapshotModeConfigurationBasedSnapshotData": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotData((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnDataError": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotOnDataError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotOnSchemaError": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotOnSchemaError((boolean) value); return true;
            case "snapshotModeConfigurationBasedSnapshotSchema": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedSnapshotSchema((boolean) value); return true;
            case "snapshotModeConfigurationBasedStartStream": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeConfigurationBasedStartStream((boolean) value); return true;
            case "snapshotModeCustomName": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSnapshotModeCustomName((java.lang.String) value); return true;
            case "sourceinfoStructMaker": getOrCreateConfiguration((DebeziumMongodbComponent) component).setSourceinfoStructMaker((java.lang.String) value); return true;
            case "streamingDelayMs": getOrCreateConfiguration((DebeziumMongodbComponent) component).setStreamingDelayMs((long) value); return true;
            case "tombstonesOnDelete": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTombstonesOnDelete((boolean) value); return true;
            case "topicNamingStrategy": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTopicNamingStrategy((java.lang.String) value); return true;
            case "topicPrefix": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTopicPrefix((java.lang.String) value); return true;
            case "transactionMetadataFactory": getOrCreateConfiguration((DebeziumMongodbComponent) component).setTransactionMetadataFactory((java.lang.String) value); return true;
            default: return false;
            }
        }

    private void updatePids(Map<Long, Pid> rows) {
        List<Long> pids;
        if (name != null) {
            pids = findPids(name);
        } else {
            pids = List.of(pid);
        }
        ProcessHandle.allProcesses()
                .filter(ph -> pids.contains(ph.pid()))
                .forEach(ph -> {
                    JsonObject root = loadStatus(ph.pid());
                    if (root != null) {
                        Pid row = new Pid();
                        row.pid = Long.toString(ph.pid());
                        JsonObject context = (JsonObject) root.get("context");
                        if (context == null) {
                            return;
                        }
                        row.name = context.getString("name");
                        if ("CamelJBang".equals(row.name)) {
                            row.name = ProcessHelper.extractName(root, ph);
                        }
                        int len = row.name.length();
                        if (len < NAME_MIN_WIDTH) {
                            len = NAME_MIN_WIDTH;
                        }
                        if (len > NAME_MAX_WIDTH) {
                            len = NAME_MAX_WIDTH;
                        }
                        if (len > nameMaxWidth) {
                            nameMaxWidth = len;
                        }
                        if (!rows.containsKey(ph.pid())) {
                            rows.put(ph.pid(), row);
                        }
                    }
                });

         
        Set<Long> remove = new HashSet<>();
        for (long pid : rows.keySet()) {
            if (!pids.contains(pid)) {
                remove.add(pid);
            }
        }
        for (long pid : remove) {
            rows.remove(pid);
        }
    }

    private void syncAllComponentsPomFile() throws MojoExecutionException {
        Path root = findCamelDirectory(project.getBasedir(), "catalog/camel-allcomponents").toPath();
        Path pomFile = root.resolve("pom.xml");

        final String startDependenciesMarker = "<dependencies>";
        final String endDependenciesMarker = "</dependencies>";

        if (!Files.isRegularFile(pomFile)) {
            throw new MojoExecutionException("Pom file " + pomFile + " does not exist");
        }

        try {
            final String pomText = loadText(pomFile);

            final String before = Strings.before(pomText, startDependenciesMarker);
            final String after = Strings.after(pomText, endDependenciesMarker);

            final String between = pomText.substring(before.length(), pomText.length() - after.length());

             
            Pattern pattern = Pattern.compile(
                    "<dependency>\\s*<groupId>(?<groupId>.*)</groupId>\\s*<artifactId>(?<artifactId>.*)</artifactId>");
            Matcher matcher = pattern.matcher(between);
            TreeSet<MavenGav> dependencies = new TreeSet<>();
            while (matcher.find()) {
                MavenGav gav = new MavenGav(matcher.group(1), matcher.group(2), "${project.version}", null);
                dependencies.add(gav);
            }
             
            dependencies.add(new MavenGav(project.getGroupId(), project.getArtifactId(), "${project.version}", null));

             
            String s = dependencies.stream()
                     
                    .filter(g -> !g.artifactId.contains("-maven-plugin"))
                    .map(g -> g.asString("        "))
                    .collect(Collectors.joining("\n"));
            final String updatedPom = before + startDependenciesMarker
                                      + "\n" + s + "\n"
                                      + "    " + endDependenciesMarker + after;

            updateResource(root, "pom.xml", updatedPom);
        } catch (IOException e) {
            throw new MojoExecutionException("Error reading file " + pomFile + " Reason: " + e, e);
        }
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
            MicrometerObservationSpanAdapter camelSpan = (MicrometerObservationSpanAdapter) ActiveSpanManager.getSpan(exchange);
            Observation observation = camelSpan.getMicrometerObservation();
            if (observation != null) {
                String tag = expression.evaluate(exchange, String.class);
                observation.highCardinalityKeyValue(attributeName, tag);
            } else {
                LOG.warn("Micrometer Observation: Cannot find managed span for exchange: {}", exchange);
            }
        } catch (Exception e) {
            exchange.setException(e);
        } finally {
             
            callback.done(true);
        }

        return true;
    }

    public void setSecureRandomName(String randomName) {
        if (context != null && randomName != null) {
            SecureRandom random = context.getRegistry().lookupByNameAndType(randomName, SecureRandom.class);
            if (keystore != null) {
                setSecureRandom(random);
            }
        }
        if (randomName != null) {
            this.secureRandomName = randomName;
        }
    }

    private void setAdditionalConfiguration(RestConfiguration config, String prefix, PropertyBindingSupport.Builder builder) {
        if (config.getDataFormatProperties() != null && !config.getDataFormatProperties().isEmpty()) {
             
             
            Map<String, Object> copy = new HashMap<>();

             
             
             
            for (Map.Entry<String, Object> entry : config.getDataFormatProperties().entrySet()) {
                String key = entry.getKey();
                String copyKey;
                boolean known = isKeyKnownPrefix(key);
                if (known) {
                     
                    copyKey = key.substring(prefix.length());
                } else {
                     
                    copyKey = key;
                }
                if (!known || key.startsWith(prefix)) {
                    copy.put(copyKey, entry.getValue());
                }
            }

            builder.withProperties(copy);
        }
    }

    public static HttpMethods createMethod(Exchange exchange, HttpCommonEndpoint endpoint, boolean hasPayload)
            throws URISyntaxException {
         
        String queryString = exchange.getIn().getHeader(Exchange.HTTP_QUERY, String.class);
         
        String uriString = exchange.getIn().getHeader(Exchange.HTTP_URI, String.class);
         
        try {
            uriString = exchange.getContext().resolvePropertyPlaceholders(uriString);
        } catch (Exception e) {
            throw new RuntimeExchangeException("Cannot resolve property placeholders with uri: " + uriString, exchange, e);
        }
        if (uriString != null) {
             
            uriString = UnsafeUriCharactersEncoder.encodeHttpURI(uriString);
            URI uri = new URI(uriString);
            queryString = uri.getQuery();
        }
        if (queryString == null) {
            queryString = endpoint.getHttpUri().getRawQuery();
        }

        HttpMethods answer;
        if (endpoint.getHttpMethod() != null) {
             
            answer = endpoint.getHttpMethod();
        } else {
             
            HttpMethods m = exchange.getIn().getHeader(Exchange.HTTP_METHOD, HttpMethods.class);
            if (m != null) {
                 
                answer = m;
            } else if (queryString != null) {
                 
                answer = HttpMethods.GET;
            } else {
                 
                answer = hasPayload ? HttpMethods.POST : HttpMethods.GET;
            }
        }

        return answer;
    }

    private Object getValue(final Message message, final String type) throws Exception {
        Object value = message.getHeader(CaffeineConstants.VALUE);
        if (value == null) {
            if (type != null) {
                Class<?> clazz = getEndpoint().getCamelContext().getClassResolver().resolveClass(type);
                value = message.getBody(clazz);
            } else {
                value = message.getBody();
            }
        }

        if (value == null) {
            throw new CamelExchangeException(
                    "No value provided in header or body (" + CaffeineConstants.VALUE + ")", message.getExchange());
        }

        return value;
    }

    private DaprOperationResponse waitForInstanceCompletion(Exchange exchange, DaprWorkflowClient client) {
        String instanceId = configurationOptionsProxy.getWorkflowInstanceId(exchange);
        Duration timeout = configurationOptionsProxy.getTimeout(exchange);
        boolean getWorkflowIO = configurationOptionsProxy.getWorkflowIO(exchange);

        try {
            WorkflowInstanceStatus response = client.waitForInstanceCompletion(instanceId, timeout, getWorkflowIO);
            return DaprOperationResponse.createFromWorkflowStatus(response);
        } catch (TimeoutException exception) {
            throw new RuntimeCamelException(
                    "Workflow instance " + instanceId + " could not be completed in " + timeout, exception);
        }
    }

    private void updateGroup(Exchange exchange, ClientConfigurations clientConfigurations) {
         
        Object body = exchange.getMessage().getBody();
        KeystoneUpdateGroupOption groupOption;
        if (body instanceof KeystoneUpdateGroupOption) {
            groupOption = (KeystoneUpdateGroupOption) body;
        } else if (body instanceof String) {
            String strBody = (String) body;
            try {
                groupOption = new ObjectMapper().readValue(strBody, KeystoneUpdateGroupOption.class);
            } catch (JsonProcessingException e) {
                throw new IllegalArgumentException("String request body must be a valid JSON with the proper keys");
            }
        } else {
            throw new IllegalArgumentException(
                    "Exchange body is mandatory and should be a valid JSON string or KeystoneUpdateGroupOption object");
        }

         
        if (ObjectHelper.isEmpty(clientConfigurations.getGroupId())) {
            if (LOG.isErrorEnabled()) {
                LOG.error("No group id given");
            }
            throw new IllegalArgumentException("Group id is mandatory to update group");
        }

         
        KeystoneUpdateGroupRequestBody requestBody = new KeystoneUpdateGroupRequestBody()
                .withGroup(groupOption);
        KeystoneUpdateGroupRequest request = new KeystoneUpdateGroupRequest()
                .withBody(requestBody)
                .withGroupId(clientConfigurations.getGroupId());
        KeystoneUpdateGroupResponse response = iamClient.keystoneUpdateGroup(request);
        exchange.getMessage().setBody(gson.toJson(response.getGroup()));
    }

        protected void onExceptionOccurred() {
            if (onExceptionProcessor == null) {
                return;
            }

             
            try {
                if (LOG.isTraceEnabled()) {
                    LOG.trace("OnExceptionOccurred processor {} is processing Exchange: {} due exception occurred",
                            onExceptionProcessor, exchange);
                }
                onExceptionProcessor.process(exchange);
            } catch (Exception e) {
                 
                LOG.warn("Error during processing OnExceptionOccurred. This exception is ignored.", e);
            }
            LOG.trace("OnExceptionOccurred processor done");
        }

    private void getPronunciation(Exchange exchange) {
        TextToSpeech tts = getEndpoint().getTtsClient();
        if (tts == null) {
            throw new IllegalStateException("TTS client not initialized");
        }

        String word = exchange.getIn().getHeader(WatsonTextToSpeechConstants.WORD, String.class);
        if (word == null) {
            word = exchange.getIn().getBody(String.class);
        }

        if (word == null || word.isBlank()) {
            throw new IllegalArgumentException("Word must be specified");
        }

        String voice = exchange.getIn().getHeader(WatsonTextToSpeechConstants.VOICE,
                getEndpoint().getConfiguration().getVoice(), String.class);
        String format = exchange.getIn().getHeader(WatsonTextToSpeechConstants.FORMAT, String.class);

        LOG.trace("Getting pronunciation for word: {}, voice: {}, format: {}", word, voice, format);

        GetPronunciationOptions.Builder builder = new GetPronunciationOptions.Builder()
                .text(word)
                .voice(voice);

        if (format != null && !format.isBlank()) {
            builder.format(format);
        }

        GetPronunciationOptions options = builder.build();
        Pronunciation pronunciation = tts.getPronunciation(options).execute().getResult();

        Message message = getMessageForResponse(exchange);
        message.setBody(pronunciation);
    }

    public void process(Exchange exchange) throws Exception {

        if (logger.isDebugEnabled()) {
             
             
             
            logger.debug("uploader thread/id: {} / {}. api call completed.", Thread.currentThread().getId(),
                    exchange.getExchangeId());
        }

        if (exchange.getIn().getBody() instanceof List) {
            boolean groupedExchanges = false;
            for (Object body : exchange.getIn().getBody(List.class)) {
                if (body instanceof Exchange) {
                    send((Exchange) body);
                    groupedExchanges = true;
                }
            }
            if (!groupedExchanges) {
                send(exchange);
            }
        } else {
            send(exchange);
        }
    }

    public V take() throws InterruptedException {
        final ReentrantLock lock = this.lock;
        lock.lockInterruptibly();
        try {
            for (;;) {
                Task t = queue.peek();
                if (t != null && (!ordered || index.compareAndSet(t.id, t.id + 1))) {
                    queue.poll();
                    return t.result;
                }
                available.await();
            }
        } finally {
            lock.unlock();
        }
    }

    public FluentProducerTemplate withExchangeProperty(String key, Object value) {
        DefaultFluentProducerTemplate clone = checkCloned();

        if (clone.processorSupplier != null) {
            throw new IllegalArgumentException(
                    "Cannot use both withExchangeProperty and withProcessor with FluentProducerTemplate");
        }

        Map<String, Object> map = clone.exchangeProperties;
        if (map == null) {
            map = new LinkedHashMap<>();
            clone.exchangeProperties = map;
        }
        map.put(key, value);
        return clone;
    }

    private void createClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().create((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientRepresentation client = new ClientRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID))) {
                String clientId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID, String.class);
                client.setClientId(clientId);
                client.setEnabled(true);
            } else {
                throw new IllegalArgumentException(MISSING_CLIENT_ID);
            }
            Response response = keycloakClient.realm(realmName).clients().create(client);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    public void changeJobState(
            String jobId, JobStateEnum state, Map<String, List<String>> headers, JobResponseCallback callback) {
        final Request request = getRequest(HttpMethod.PATCH, jobUrl(jobId), headers);
        Job job = new Job();
        job.setId(jobId);
        job.setState(state);
        try {
            marshalRequest(job, request);
        } catch (SalesforceException e) {
            callback.onResponse(null, Collections.emptyMap(), e);
            return;
        }
        doHttpRequest(request, new ClientResponseCallback() {
            @Override
            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                if (ex != null) {
                    callback.onResponse(null, headers, ex);
                }
                Job responseJob = null;
                try {
                    responseJob = unmarshalResponse(response, request, Job.class);
                } catch (SalesforceException e) {
                    ex = e;
                }
                callback.onResponse(responseJob, headers, ex);
            }
        });
    }

    public boolean acquireExclusiveReadLock(GenericFileOperations<File> operations, GenericFile<File> file, Exchange exchange)
            throws Exception {
         
         
        File path = file.getFile();
        if (!path.exists()) {
            return false;
        }

         
        String key = asKey(exchange, file);
        boolean answer = false;
        try {
            answer = idempotentRepository.add(exchange, key);
        } catch (Exception e) {
            if (LOG.isTraceEnabled()) {
                LOG.trace("Cannot acquire read lock due to {}. Will skip the file: {}", e.getMessage(), file, e);
            }
        }
        if (!answer) {
             
            CamelLogger.log(LOG, readLockLoggingLevel, "Cannot acquire read lock. Will skip the file: " + file);
        }
        return answer;
    }

    private LogContainerCmd executeLogContainerRequest(DockerClient client, Message message) {

        LOG.debug("Executing Docker Log Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        ObjectHelper.notNull(containerId, MISSING_CONTAINER_ID);

        LogContainerCmd logContainerCmd = client.logContainerCmd(containerId);

        Boolean followStream
                = DockerHelper.getProperty(DockerConstants.DOCKER_FOLLOW_STREAM, configuration, message, Boolean.class);

        if (followStream != null) {
            logContainerCmd.withFollowStream(followStream);
        }

        Boolean stdErr = DockerHelper.getProperty(DockerConstants.DOCKER_STD_ERR, configuration, message, Boolean.class);

        if (stdErr != null) {
            logContainerCmd.withStdErr(stdErr);
        }

        Boolean stdOut = DockerHelper.getProperty(DockerConstants.DOCKER_STD_OUT, configuration, message, Boolean.class);

        if (stdOut != null) {
            logContainerCmd.withStdOut(stdOut);
        }

        Integer tail = DockerHelper.getProperty(DockerConstants.DOCKER_TAIL, configuration, message, Integer.class);

        if (tail != null) {
            logContainerCmd.withTail(tail);
        }

        Boolean tailAll = DockerHelper.getProperty(DockerConstants.DOCKER_TAIL_ALL, configuration, message, Boolean.class);

        if (tailAll != null && tailAll) {
            logContainerCmd.withTailAll();
        }

        Boolean timestamps = DockerHelper.getProperty(DockerConstants.DOCKER_TIMESTAMPS, configuration, message, Boolean.class);

        if (timestamps != null) {
            logContainerCmd.withTimestamps(timestamps);
        }

        return logContainerCmd;

    }

    private String parseTopicName(String uri) {
         
        uri = uri.replaceFirst(scheme + "://", ":");

        uri = StringHelper.before(uri, "?", uri);
         

        int pos = uri.indexOf(':');
        if (pos != -1) {
            return uri.substring(pos + 1);
        } else {
            return null;
        }
    }

    public static void closeAllServerConnections() {
        for (Map.Entry<Integer, AS2ServerConnection> entry : serverConnections.entrySet()) {
            try {
                int port = entry.getKey();
                LOG.debug("Stopping and closing AS2ServerConnection on port: {}", port);
                AS2ServerConnection conn = entry.getValue();
                conn.close();
            } catch (Exception e) {
                 
                LOG.debug("Error stopping and closing AS2ServerConnection due to {}. This exception is ignored",
                        e.getMessage(), e);
            }
        }
        serverConnections.clear();
    }

    private JsonObject asJsonObject(DevConsoleModel model) {
        JsonObject jo = new JsonObject();
         
        jo.put("kind", "console");
        if (model.group != null) {
            jo.put("group", model.getGroup());
        } else {
            jo.put("group", "camel");
        }
        jo.put("name", model.getName());
        if (model.getDisplayName() != null) {
            jo.put("title", asTitle(model.getDisplayName()));
        } else {
            jo.put("title", asTitle(model.getName()));
        }
        jo.put("description", model.getDescription());
        jo.put("deprecated", model.isDeprecated());
        jo.put("javaType", model.getClassName());
        jo.put("groupId", project.getGroupId());
        jo.put("artifactId", project.getArtifactId());
        jo.put("version", project.getVersion());
        JsonObject root = new JsonObject();
        root.put("console", jo);
        return root;
    }

    private void doCreateOrUpdateNode(Exchange exchange, String operationName, Function<Resource<Node>, Node> operation) {
        String nodeName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NODE_NAME, String.class);
        NodeSpec nodeSpec = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NODE_SPEC, NodeSpec.class);
        if (ObjectHelper.isEmpty(nodeName)) {
            LOG.error("{} a specific node require specify a node name", operationName);
            throw new IllegalArgumentException(String.format("%s a specific node require specify a node name", operationName));
        }
        if (ObjectHelper.isEmpty(nodeSpec)) {
            LOG.error("{} a specific node require specify a node spec bean", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific node require specify a node spec bean", operationName));
        }
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PODS_LABELS, Map.class);
        Node nodeCreating = new NodeBuilder().withNewMetadata().withName(nodeName).withLabels(labels).endMetadata()
                .withSpec(nodeSpec).build();
        Node node = operation.apply(getEndpoint().getKubernetesClient().nodes().resource(nodeCreating));

        prepareOutboundMessage(exchange, node);
    }

    private void doUpdateList(Exchange exchange, SqlSession session) {
        Object result;
        Object in = getInput(exchange);
        if (in != null) {
             
            LOG.trace("Updating: {} using statement: {}", in, statement);
            result = session.update(statement, in);
            doProcessResult(exchange, result, session);
        } else {
            LOG.trace("Updating using statement: {}", statement);
            result = session.update(statement);
            doProcessResult(exchange, result, session);
        }
    }

    public static Set<String> asStringSet(Node node) {
        if (node == null) {
            return null;
        }

        final Set<String> answer;

        if (node.getNodeType() == NodeType.SCALAR) {
            answer = asStringSet(asText(node));
        } else if (node.getNodeType() == NodeType.SEQUENCE) {
            answer = new LinkedHashSet<>();
            for (Node item : asSequenceNode(node).getValue()) {
                answer.add(asText(item));
            }
        } else {
            throw new UnsupportedNodeTypeException(node);
        }

        return answer;
    }

    public void initialize(Server server, Bus bus) {
        server.getEndpoint().put("org.apache.cxf.binding.soap.addNamespaceContext", "true");
        server.getEndpoint().getBinding().getInInterceptors().add(new ConfigureDocLitWrapperInterceptor(true));
        if (server.getEndpoint().getBinding() instanceof SoapBinding) {
            server.getEndpoint().getBinding().getOutInterceptors().add(new SetSoapVersionInterceptor());
        }
         
         
        removeInterceptor(server.getEndpoint().getInInterceptors(),
                HolderInInterceptor.class);
        removeInterceptor(server.getEndpoint().getOutInterceptors(),
                HolderOutInterceptor.class);
        removeInterceptor(server.getEndpoint().getBinding().getInInterceptors(),
                SoapHeaderInterceptor.class);
        resetPartTypes(server.getEndpoint().getBinding());

        LOG.info("Initialized CXF Server: {} in Payload mode with allow streaming: {}", server, allowStreaming);
    }

    public static Predicate isEqualToIgnoreCase(final Expression left, final Expression right) {
        return new BinaryPredicateSupport(left, right) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue == null && rightValue == null) {
                     
                    return true;
                } else if (leftValue == null || rightValue == null) {
                     
                    return false;
                }

                return ObjectHelper.typeCoerceEquals(exchange.getContext().getTypeConverter(), leftValue, rightValue, true);
            }

            protected String getOperationText() {
                return "=~";
            }
        };
    }

    public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
        if (key == null || value == null || remappingFunction == null) {
            throw new NullPointerException();
        }
        for (;;) {
            SoftReference<V> ref = delegate.get(key);
            V oldValue = ref == null ? null : ref.get();
            V newValue = oldValue == null ? value : remappingFunction.apply(oldValue, value);
            if (newValue == null) {
                if (!delegate.remove(key, ref)) {
                     
                    continue;
                }
            } else if (ref == null) {
                if (delegate.putIfAbsent(key, new SoftReference<>(newValue)) != null) {
                     
                    continue;
                }
            } else if (!delegate.replace(key, ref, new SoftReference<>(newValue))) {
                 
                continue;
            }
            return newValue;
        }
    }

    public void onNext(Object request) {
        CountDownLatch latch = new CountDownLatch(1);

        exchange = endpoint.createExchange();
        exchange.getIn().setBody(request);
        exchange.getIn().setHeaders(headers);

        consumer.process(exchange, doneSync -> latch.countDown());

        try {
            latch.await();

            Object responseBody = exchange.getMessage().getBody();
            if (responseBody instanceof List) {
                List<?> responseList = (List<?>) responseBody;
                responseList.forEach(responseObserver::onNext);
            } else {
                responseObserver.onNext(responseBody);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            responseObserver.onError(e);

        }
    }

    public String getString(final String key) {
        Object returnable = this.get(key);
        if (returnable instanceof Boolean) {
            returnable = returnable.toString();
        } else if (returnable instanceof Number) {
            returnable = returnable.toString();
        }
        return (String) returnable;
    }

    public Service newHttpManagementServer(
            CamelContext camelContext, HttpManagementServerConfigurationProperties configuration) {
        ManagementHttpServer server = new ManagementHttpServer();

        server.setCamelContext(camelContext);
        server.setHost(configuration.getHost());
        server.setPort(configuration.getPort());
        server.setPath(configuration.getPath());

        server.setUseGlobalSslContextParameters(configuration.isUseGlobalSslContextParameters());
        server.setInfoEnabled(configuration.isInfoEnabled());
        server.setDevConsoleEnabled(configuration.isDevConsoleEnabled());
        server.setHealthCheckEnabled(configuration.isHealthCheckEnabled());
        server.setHealthPath(configuration.getHealthPath());
        server.setInfoPath(configuration.getInfoPath());
        server.setJolokiaEnabled(configuration.isJolokiaEnabled());
        server.setJolokiaPath(configuration.getJolokiaPath());
        server.setMetricsEnabled(configuration.isMetricsEnabled());
        server.setUploadEnabled(configuration.isUploadEnabled());
        server.setUploadSourceDir(configuration.getUploadSourceDir());
        server.setDownloadEnabled(configuration.isDownloadEnabled());
        server.setSendEnabled(configuration.isSendEnabled());

        if (configuration.isAuthenticationEnabled()) {
            configureAuthentication(server, configuration);
        }

        return server;
    }

    public TabularData listValidators() {
        try {
            TabularData answer = new TabularDataSupport(CamelOpenMBeanTypes.listValidatorsTabularType());
            Collection<Validator> validators = validatorRegistry.values();
            for (Validator validator : validators) {
                CompositeType ct = CamelOpenMBeanTypes.listValidatorsCompositeType();
                DataType type = validator.getType();
                String desc = validator.toString();
                boolean isStatic = validatorRegistry.isStatic(type);
                boolean isDynamic = validatorRegistry.isDynamic(type);

                CompositeData data = new CompositeDataSupport(
                        ct, new String[] { "type", "static", "dynamic", "description" },
                        new Object[] { type.toString(), isStatic, isDynamic, desc });
                answer.put(data);
            }
            return answer;
        } catch (Exception e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    private void updateIdentityProvider(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String idpAlias = exchange.getIn().getHeader(KeycloakConstants.IDP_ALIAS, String.class);
        if (ObjectHelper.isEmpty(idpAlias)) {
            throw new IllegalArgumentException("Identity provider alias must be specified");
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof IdentityProviderRepresentation) {
                keycloakClient.realm(realmName).identityProviders().get(idpAlias)
                        .update((IdentityProviderRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody("Identity provider updated successfully");
            }
        } else {
            throw new IllegalArgumentException(
                    "Update identity provider requires POJO request with IdentityProviderRepresentation");
        }
    }

    public void configureAuthentication(
            AuthenticationConfig authenticationConfig,
            HttpManagementServerConfigurationProperties properties) {
        String authPropertiesFileName = properties.getBasicPropertiesFile();
        String path
                = isNotEmpty(properties.getAuthenticationPath()) ? properties.getAuthenticationPath() : properties.getPath();
         
        if ("/".equals(path)) {
            path = "/*";
        }
        String realm = properties.getAuthenticationRealm() != null ? properties.getAuthenticationRealm() : DEFAULT_REALM;

        AuthenticationConfigEntry entry = new AuthenticationConfigEntry();
        entry.setPath(path);
        entry.setAuthenticationHandlerFactory(new AuthenticationConfig.AuthenticationHandlerFactory() {
            @Override
            public <T extends AuthenticationProvider> AuthenticationHandler createAuthenticationHandler(
                    T authenticationProvider) {
                return BasicAuthHandler.create(authenticationProvider, realm);
            }
        });
        entry.setAuthenticationProviderFactory(
                vertx -> PropertyFileAuthentication.create(vertx, authPropertiesFileName));

        authenticationConfig.getEntries().add(entry);
        authenticationConfig.setEnabled(true);
    }

    public static void closeAllAsyncMdnServerConnections() {
        for (Map.Entry<Integer, AS2AsyncMDNServerConnection> entry : asyncMdnServerConnections.entrySet()) {
            try {
                int port = entry.getKey();
                LOG.debug("Stopping and closing AsyncMdnServerConnection on port: {}", port);
                entry.getValue().close();
            } catch (Exception e) {
                LOG.debug("Error stopping and closing AsyncMdnServerConnection due to {}. This exception is ignored",
                        e.getMessage(), e);
            }
        }
        asyncMdnServerConnections.clear();
    }

    public static Expression bodyOgnlExpression(final String ognl) {
        return new ExpressionAdapter() {
            private Language bean;

            @Override
            public Object evaluate(Exchange exchange) {
                Object body = exchange.getIn().getBody();
                if (body == null) {
                    return null;
                }
                Expression ognlExp = bean.createExpression(null, new Object[] { null, body, ognl });
                ognlExp.init(exchange.getContext());
                return ognlExp.evaluate(exchange, Object.class);
            }

            @Override
            public void init(CamelContext context) {
                bean = context.resolveLanguage("bean");
            }

            @Override
            public String toString() {
                return "bodyOgnl(" + ognl + ")";
            }
        };
    }

    private void processGetAllBatches(final Exchange exchange, final AsyncCallback callback) throws SalesforceException {
        JobInfo jobBody;
        String jobId;
        jobBody = exchange.getIn().getBody(JobInfo.class);
        if (jobBody != null) {
            jobId = jobBody.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getAllBatches(jobId, determineHeaders(exchange), new BulkApiClient.BatchInfoListResponseCallback() {
            @Override
            public void onResponse(List<BatchInfo> batchInfoList, Map<String, String> headers, SalesforceException ex) {
                processResponse(exchange, batchInfoList, headers, ex, callback);
            }
        });
    }

    public Object sendBodyAndHeader(
            Endpoint endpoint, ExchangePattern pattern, final Object body,
            final String header, final Object headerValue)
            throws CamelExecutionException {
        Exchange exchange = send(endpoint, pattern, createBodyAndHeaderProcessor(body, header, headerValue));
        Object result = extractResultBody(exchange, pattern);
        if (pattern == ExchangePattern.InOnly) {
             
            return null;
        } else {
            return result;
        }
    }

    public CreateIssueProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_ISSUE_SERVICE);
        if (service != null) {
            issueService = (IssueService) service;
        } else {
            issueService = new IssueService();
        }
        initService(issueService);
    }

        protected void doStop() throws Exception {
            super.doStop();

            this.running.set(false);

            if (cache != null) {
                cache.removeClientListener(this);
            }

            getCamelContext().getExecutorServiceManager().shutdownGraceful(executorService);

            if (cache != null) {
                if (this.version != null) {
                    cache.removeWithVersion(InfinispanClusterService.LEADER_KEY, this.version);
                }

                LOGGER.info("Removing local member, key={}", getLocalMember().getId());
                cache.remove(getLocalMember().getId());
            }

            this.version = null;
        }

    public DataLakeOperationResponse listPaths(final Exchange exchange) {
        final ListPathsOptions listPathsOptions = configurationProxy.getListPathOptions(exchange);
        final Duration timeout = configurationProxy.getTimeout(exchange);
        final String regex = configurationProxy.getRegex(exchange);
        List<PathItem> paths = client.listPaths(listPathsOptions, timeout);

        if (ObjectHelper.isEmpty(regex)) {
            return new DataLakeOperationResponse(paths);
        } else {
            List<PathItem> filteredPaths = paths.stream()
                    .filter(x -> x.getName().matches(regex))
                    .collect(Collectors.toCollection(LinkedList<PathItem>::new));
            return new DataLakeOperationResponse(filteredPaths);
        }
    }

    private String doCreateCode(CamelContext camelContext, String expression) throws SimpleParserException {
        ObjectHelper.notNull(left, "left node", this);
        ObjectHelper.notNull(right, "right node", this);

        final String leftExp = left.createCode(camelContext, expression);
        final String rightExp = right.createCode(camelContext, expression);

        if (operator == LogicalOperatorType.AND) {
            return leftExp + " && " + rightExp;
        } else if (operator == LogicalOperatorType.OR) {
            return leftExp + " || " + rightExp;
        }

        throw new SimpleParserException("Unknown logical operator " + operator, token.getIndex());
    }

    public SmppMessage createSmppMessage(CamelContext camelContext, DataSm dataSm, String smppMessageId) {
        SmppMessage smppMessage = new SmppMessage(camelContext, dataSm, configuration);

        smppMessage.setHeader(SmppConstants.MESSAGE_TYPE, SmppMessageType.DataSm.toString());
        smppMessage.setHeader(SmppConstants.ID, smppMessageId);
        smppMessage.setHeader(SmppConstants.SEQUENCE_NUMBER, dataSm.getSequenceNumber());
        smppMessage.setHeader(SmppConstants.COMMAND_ID, dataSm.getCommandId());
        smppMessage.setHeader(SmppConstants.COMMAND_STATUS, dataSm.getCommandStatus());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR, dataSm.getSourceAddr());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR_NPI, dataSm.getSourceAddrNpi());
        smppMessage.setHeader(SmppConstants.SOURCE_ADDR_TON, dataSm.getSourceAddrTon());
        smppMessage.setHeader(SmppConstants.DEST_ADDR, dataSm.getDestAddress());
        smppMessage.setHeader(SmppConstants.DEST_ADDR_NPI, dataSm.getDestAddrNpi());
        smppMessage.setHeader(SmppConstants.DEST_ADDR_TON, dataSm.getDestAddrTon());
        smppMessage.setHeader(SmppConstants.SERVICE_TYPE, dataSm.getServiceType());
        smppMessage.setHeader(SmppConstants.REGISTERED_DELIVERY, dataSm.getRegisteredDelivery());
        smppMessage.setHeader(SmppConstants.DATA_CODING, dataSm.getDataCoding());

        return smppMessage;
    }

    public Map<String, String> getFilters() {
        Map<String, String> answer = new HashMap<>();
        if (this.filters != null) {
            answer.putAll(this.filters);
        }
        if (this.metadata != null) {
            for (Map.Entry<String, String> entry : this.metadata.entrySet()) {
                if (entry.getKey().startsWith(Knative.KNATIVE_FILTER_PREFIX)) {
                    final String key = entry.getKey().substring(Knative.KNATIVE_FILTER_PREFIX.length());
                    final String val = entry.getValue();

                    answer.put(key, val);
                }
            }
        }

        return answer;
    }

    private boolean existsRemote(ShareFileClient fileClient) {
        try {
            return Boolean.TRUE
                    .equals(fileClient.existsWithResponse(endpoint.getMetadataTimeout(), Context.NONE).getValue());
        } catch (ShareStorageException ex) {
             
            if (ex.getStatusCode() == HTTP_NOT_FOUND) {
                return false;
            }
            throw ex;
        }
    }

    protected LongHistogram getInstrument(String name, String description) {
        LongHistogram summary = distributionSummaries.get(name);
        if (summary == null) {
            synchronized (lock) {
                summary = distributionSummaries.get(name);
                if (summary == null) {
                    Meter meter = getEndpoint().getMeter();
                    LongHistogramBuilder builder = meter.histogramBuilder(name).ofLongs();
                    if (description != null) {
                        builder.setDescription(description);
                    }
                    summary = builder.build();
                    distributionSummaries.put(name, summary);
                }
            }
        }
        return summary;
    }

    private void doAttach(Exchange exchange) {
        final Message msg = exchange.getIn();
        final String routerId = msg.getHeader(NeutronConstants.ROUTER_ID, String.class);
        final String subnetPortId
                = msg.getHeader(NeutronConstants.SUBNET_ID, msg.getHeader(NeutronConstants.PORT_ID), String.class);
        final AttachInterfaceType type = msg.getHeader(NeutronConstants.ITERFACE_TYPE, AttachInterfaceType.class);
        StringHelper.notEmpty(routerId, "Router ID");
        StringHelper.notEmpty(subnetPortId, "Subnet/Port ID");
        ObjectHelper.notNull(type, "AttachInterfaceType ");
        RouterInterface routerInterface = os.networking().router().attachInterface(routerId, type, subnetPortId);
        msg.setBody(routerInterface);
    }

    private void createResource(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        String clientUuid = exchange.getIn().getHeader(KeycloakConstants.CLIENT_UUID, String.class);
        if (ObjectHelper.isEmpty(clientUuid)) {
            throw new IllegalArgumentException(MISSING_CLIENT_UUID);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ResourceRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().get(clientUuid).authorization().resources()
                        .create((ResourceRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            throw new IllegalArgumentException("Create resource requires POJO request with ResourceRepresentation");
        }
    }

    public void execute() throws MojoExecutionException {
        File camelDir = findCamelDirectory(baseDir, "core/camel-util");
        if (camelDir == null) {
            getLog().debug("No core/camel-util folder found, skipping execution");
            return;
        }
        List<Path> jsonFiles;
        try (Stream<Path> stream = PackageHelper.findJsonFiles(jsonDir.toPath())) {
            jsonFiles = stream.toList();
        }
        Set<String> secrets = new TreeSet<>();

        for (Path file : jsonFiles) {
            final String name = PackageHelper.asName(file);

            try {
                String json = PackageHelper.loadText(file.toFile());
                Object jo = Jsoner.deserialize(json);
                JsonObject obj;
                if (jo instanceof JsonObject) {
                    obj = (JsonObject) jo;
                } else {
                    continue;
                }

                boolean isComponent = obj.getMap("component") != null;
                boolean isDataFormat = !isComponent && obj.getMap("dataformat") != null;
                boolean isLanguage = !isComponent && !isDataFormat && obj.getMap("language") != null;

                 
                if (!isComponent && !isDataFormat && !isLanguage) {
                    continue;
                }

                if (isComponent) {
                    ComponentModel cm = JsonMapper.generateComponentModel(json);
                    cm.getComponentOptions().forEach(o -> {
                        if (o.isSecret()) {
                             
                            String key = o.getName().toLowerCase(Locale.ENGLISH);
                            key = key.replace("-", "");
                            secrets.add(key);
                        }
                    });
                } else if (isDataFormat) {
                    DataFormatModel dm = JsonMapper.generateDataFormatModel(json);
                    dm.getOptions().forEach(o -> {
                        if (o.isSecret()) {
                             
                            String key = o.getName().toLowerCase(Locale.ENGLISH);
                            key = key.replace("-", "");
                            secrets.add(key);
                        }
                    });
                } else if (isLanguage) {
                    LanguageModel lm = JsonMapper.generateLanguageModel(json);
                    lm.getOptions().forEach(o -> {
                        if (o.isSecret()) {
                             
                            String key = o.getName().toLowerCase(Locale.ENGLISH);
                            key = key.replace("-", "");
                            secrets.add(key);
                        }
                    });
                }
            } catch (Exception e) {
                throw new MojoExecutionException("Error loading json: " + name, e);
            }
        }

         
        secrets.addAll(Arrays.asList(EXTRA_KEYS));

        getLog().info("There are " + secrets.size()
                      + " distinct secret options across all the Camel components/dataformats/languages");

        try {
            boolean updated = updateSensitiveHelperKeys(camelDir, secrets);
            updated |= updateSensitiveHelperPatterns(camelDir, secrets);
            if (updated) {
                getLog().info("Updated camel-util/src/main/java/org/apache/camel/util/SensitiveUtils.java file");
            } else {
                getLog().debug("No changes to camel-util/src/main/java/org/apache/camel/util/SensitiveUtils.java file");
            }
        } catch (Exception e) {
            throw new MojoExecutionException("Error updating SensitiveUtils.java", e);
        }

        try {
            updateSensitiveJsonSchema(baseDir, secrets);
        } catch (Exception e) {
            throw new MojoExecutionException("Error updating sensitive-keys.json", e);
        }
    }

    protected void execute(boolean dto) throws MojoExecutionException {
        if (skip) {
            return;
        }

        OpenAPI openapi = new OpenAPIV3Parser().read(specificationUri);

        if (openapi == null) {
            throw new MojoExecutionException(
                    "Unable to generate REST DSL OpenApi sources from specification: "
                                             + specificationUri
                                             + ", make sure that the specification is available at the given URI");
        }

        final RestDslYamlGenerator generator = RestDslGenerator.toYaml(openapi);

        if (ObjectHelper.isNotEmpty(basePath)) {
            generator.withBasePath(basePath);
        }

        if (ObjectHelper.isNotEmpty(filterOperation)) {
            generator.withOperationFilter(filterOperation);
        }
        if (dto) {
            if (modelPackage != null) {
                generator.withDtoPackageName(modelPackage);
            }
        }

        if (ObjectHelper.isNotEmpty(destinationGenerator)) {
            final DestinationGenerator destinationGeneratorObject = createDestinationGenerator();
            generator.withDestinationGenerator(destinationGeneratorObject);
        } else if (ObjectHelper.isNotEmpty(destinationToSyntax)) {
            generator.withDestinationToSyntax(destinationToSyntax);
        }

        if (restConfiguration) {
            generator.withRestComponent(findAppropriateComponent());
            if (clientRequestValidation) {
                generator.withClientRequestValidation();
            }
            if (ObjectHelper.isNotEmpty(apiContextPath)) {
                generator.withApiContextPath(apiContextPath);
            }
        }

        try {
            final CamelContext camel = new DefaultCamelContext();
            final String yaml = generator.generate(camel);

             
            new File(outputDirectory).mkdirs();
            final File out = new File(outputDirectory, fileName);

            try (FileOutputStream fos = new FileOutputStream(out)) {
                fos.write(yaml.getBytes());
            }
        } catch (final Exception e) {
            throw new MojoExecutionException(
                    "Unable to generate REST DSL OpenApi sources from specification: " + specificationUri, e);
        }
    }

    private void doCreateOrUpdateResourceQuota(
            Exchange exchange, String operationName, Function<Resource<ResourceQuota>, ResourceQuota> operation) {
        String rqName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_RESOURCES_QUOTA_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        ResourceQuotaSpec rqSpec
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_RESOURCE_QUOTA_SPEC, ResourceQuotaSpec.class);
        if (ObjectHelper.isEmpty(rqName)) {
            LOG.error("{} a specific resource quota require specify a resource quota name", operationName);
            throw new IllegalArgumentException(
                    operationName + " a specific resource quota require specify a resource quota name");
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific resource quota require specify a namespace name", operationName);
            throw new IllegalArgumentException(operationName + " a specific resource quota require specify a namespace name");
        }
        if (ObjectHelper.isEmpty(rqSpec)) {
            LOG.error("{} a specific resource quota require specify a resource quota spec bean", operationName);
            throw new IllegalArgumentException(
                    operationName + " a specific resource quota require specify a resource quota spec bean");
        }
        Map<String, String> labels
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_RESOURCES_QUOTA_LABELS, Map.class);
        ResourceQuota rqCreating = new ResourceQuotaBuilder().withNewMetadata().withName(rqName).withLabels(labels)
                .endMetadata().withSpec(rqSpec).build();
        ResourceQuota rq
                = operation.apply(
                        getEndpoint().getKubernetesClient().resourceQuotas().inNamespace(namespaceName).resource(rqCreating));

        prepareOutboundMessage(exchange, rq);
    }

    protected Object doInvokeMethod(Map<String, Object> properties) throws RuntimeCamelException {
        AbstractGoogleClientRequest request = (AbstractGoogleClientRequest) super.doInvokeMethod(properties);
        try {
            BeanIntrospection beanIntrospection
                    = PluginHelper.getBeanIntrospection(getEndpoint().getCamelContext());
            for (Entry<String, Object> p : properties.entrySet()) {
                beanIntrospection.setProperty(getEndpoint().getCamelContext(), request, p.getKey(), p.getValue());
            }
            return request.execute();
        } catch (Exception e) {
            throw new RuntimeCamelException(e);
        }
    }

    protected ReplyManager createReplyManager(String replyTo) throws Exception {
         
        ReplyManager replyManager = new QueueReplyManager(getEndpoint().getCamelContext());
        replyManager.setEndpoint(getEndpoint());

        String name = "JmsReplyManagerTimeoutChecker[" + replyTo + "]";
        ScheduledExecutorService replyManagerScheduledExecutorService
                = getEndpoint().getCamelContext().getExecutorServiceManager().newSingleThreadScheduledExecutor(this, name);
        replyManager.setScheduledExecutorService(replyManagerScheduledExecutorService);

        name = "JmsReplyManagerOnTimeout[" + replyTo + "]";
         
        ExecutorService replyManagerExecutorService = createReplyManagerExecutor(replyManager, name);
        replyManager.setOnTimeoutExecutorService(replyManagerExecutorService);

        ServiceHelper.startService(replyManager);

        return replyManager;
    }

    public Processor createProcessor() throws Exception {
        if (definition.getHeaders().isEmpty()) {
            throw new IllegalArgumentException("There must be at least one header specified");
        }
        List<Expression> nameExprs = new java.util.ArrayList<>(definition.getHeaders().size());
        List<Expression> valueExprs = new java.util.ArrayList<>(definition.getHeaders().size());
        for (SetHeaderDefinition hdrDef : definition.getHeaders()) {
            valueExprs.add(createExpression(hdrDef.getExpression()));
            Expression nameExpr;
            String key = parseString(hdrDef.getName());
            if (LanguageSupport.hasSimpleFunction(key)) {
                nameExpr = camelContext.resolveLanguage("simple").createExpression(key);
            } else {
                nameExpr = camelContext.resolveLanguage("constant").createExpression(key);
            }
            nameExpr.init(camelContext);
            nameExprs.add(nameExpr);
        }

        SetHeadersProcessor answer = new SetHeadersProcessor(nameExprs, valueExprs);
        answer.setDisabled(isDisabled(camelContext, definition));
        return answer;
    }

    public String dumpStatisticsAsJsonTimeUnitSeconds() {
        ObjectWriter writer = secondsMapper.writer();
        if (isPrettyPrint()) {
            writer = writer.withDefaultPrettyPrinter();
        }
        try {
            return writer.writeValueAsString(getMetricsRegistry());
        } catch (JsonProcessingException e) {
            throw RuntimeCamelException.wrapRuntimeCamelException(e);
        }
    }

    private static GenericFileExclusiveReadLockStrategy<FTPFile> getExclusiveReadLockStrategy(Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<FTPFile> strategy
                = (GenericFileExclusiveReadLockStrategy<FTPFile>) params.get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<FTPFile> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                FtpChangedExclusiveReadLockStrategy readLockStrategy = new FtpChangedExclusiveReadLockStrategy();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            }
        }

        return null;
    }

    public static void doWithClasses(Class<?> clazz, ClassCallback cc) throws IllegalArgumentException {
         
        Class<?>[] classes = clazz.getDeclaredClasses();
        for (Class<?> aClazz : classes) {
            try {
                cc.doWith(aClazz);
            } catch (IllegalAccessException ex) {
                throw new IllegalStateException("Shouldn't be illegal to access class '" + aClazz.getName() + "': " + ex);
            }
        }
    }

    protected void doStart() throws Exception {
        super.doStart();

        if (getCamelContext().getPropertiesComponent().hasPropertiesFunction("azure")) {
            PropertiesFunction pf = getCamelContext().getPropertiesComponent().getPropertiesFunction("azure");
            if (pf instanceof KeyVaultPropertiesFunction) {
                propertiesFunction = (KeyVaultPropertiesFunction) pf;
            }
        }
        AzureVaultConfiguration azure = getCamelContext().getVaultConfiguration().getAzureVaultConfiguration();
        if (azure != null && azure.isRefreshEnabled()) {
            PeriodTaskScheduler scheduler = PluginHelper.getPeriodTaskScheduler(getCamelContext());
            secretsRefreshTask = scheduler.getTaskByType(EventhubsReloadTriggerTask.class);
        }
    }

    public Service newHttpManagementServer(
            CamelContext camelContext, HttpManagementServerConfigurationProperties configuration) {
        ManagementHttpServer server = new ManagementHttpServer();

        server.setCamelContext(camelContext);
        server.setHost(configuration.getHost());
        server.setPort(configuration.getPort());
        server.setPath(configuration.getPath());

        server.setUseGlobalSslContextParameters(configuration.isUseGlobalSslContextParameters());
        server.setInfoEnabled(configuration.isInfoEnabled());
        server.setDevConsoleEnabled(configuration.isDevConsoleEnabled());
        server.setHealthCheckEnabled(configuration.isHealthCheckEnabled());
        server.setHealthPath(configuration.getHealthPath());
        server.setInfoPath(configuration.getInfoPath());
        server.setJolokiaEnabled(configuration.isJolokiaEnabled());
        server.setJolokiaPath(configuration.getJolokiaPath());
        server.setMetricsEnabled(configuration.isMetricsEnabled());
        server.setUploadEnabled(configuration.isUploadEnabled());
        server.setUploadSourceDir(configuration.getUploadSourceDir());
        server.setDownloadEnabled(configuration.isDownloadEnabled());
        server.setSendEnabled(configuration.isSendEnabled());

        if (configuration.isAuthenticationEnabled()) {
            configureAuthentication(server, configuration);
        }

        return server;
    }

    public Exchange send() throws CamelExecutionException {
        DefaultFluentProducerTemplate clone = checkCloned();

         
        final Endpoint target = clone.target();

        Exchange result;
        Exchange exchange = clone.exchangeSupplier != null ? clone.exchangeSupplier.get() : null;
        if (exchange != null) {
            result = clone.template().send(target, exchange);
        } else {
            Processor proc = clone.processorSupplier != null ? clone.processorSupplier.get() : null;
            final Processor processor = proc != null ? proc : clone.defaultProcessor();
            result = clone.template().send(target, processor);
        }

         
        cloned = false;
        useDefaultEndpoint = true;

        return result;
    }

    public KeyStoreParameters getObject() throws Exception {
        if (this.isSingleton()) {
            if (instance == null) {
                instance = createInstance();
            }
            return instance;
        } else {
            return createInstance();
        }
    }

    public Processor createErrorHandler(Processor processor) throws Exception {
         
        TransactionTemplate transactionTemplate = resolveTransactionTemplate(definition);
        ObjectHelper.notNull(transactionTemplate, "transactionTemplate", this);

         
        RedeliveryPolicy redeliveryPolicy = resolveRedeliveryPolicy(definition, camelContext);
        CamelLogger logger = resolveLogger(definition);
        LoggingLevel rollbackLoggingLevel = resolveRollbackLoggingLevel(definition);

        TransactionErrorHandler answer = new TransactionErrorHandler(
                camelContext, processor, logger,
                getProcessor(definition.getOnRedeliveryProcessor(), definition.getOnRedeliveryRef()),
                redeliveryPolicy,
                transactionTemplate,
                resolveRetryWhilePolicy(definition, camelContext),
                getExecutorService(definition.getExecutorServiceBean(), definition.getExecutorServiceRef()),
                rollbackLoggingLevel,
                getProcessor(definition.getOnExceptionOccurredProcessor(), definition.getOnExceptionOccurredRef()));
         
        configure(answer);
        return answer;
    }

    private String getAlgorithmName(String algorithm) {
        try {
            return PQCSignatureAlgorithms.valueOf(algorithm).getAlgorithm();
        } catch (IllegalArgumentException e1) {
            try {
                return PQCKeyEncapsulationAlgorithms.valueOf(algorithm).getAlgorithm();
            } catch (IllegalArgumentException e2) {
                return algorithm;
            }
        }
    }

        Object next(boolean first) {
            Object answer = image;
             
            if (scanner.hasNext()) {
                image = getNext(first);
            } else {
                image = null;
            }

            if (answer == null) {
                 
                answer = image;
            }
            return answer;
        }

    public static Predicate isNotNull(final Expression expression) {
        return new BinaryPredicateSupport(expression, ExpressionBuilder.constantExpression(null)) {

            protected boolean matches(Exchange exchange, Object leftValue, Object rightValue) {
                if (leftValue != null) {
                     
                    return true;
                }
                 
                return ObjectHelper.typeCoerceNotEquals(exchange.getContext().getTypeConverter(), leftValue, rightValue);
            }

            protected String getOperationText() {
                 
                 
                return "is not";
            }
        };
    }

    public String dumpLatestMessageHistoryAsJSon() {
        List<BacklogTracerEventMessage> events = dumpLatestMessageHistory();

        JsonObject root = new JsonObject();
        JsonArray arr = new JsonArray();
        root.put("traces", arr);
        for (BacklogTracerEventMessage event : events) {
            arr.add(event.asJSon());
        }
        return Jsoner.prettyPrint(root.toJson());
    }

    protected String getNamespace(String uriExpression) {
        String namespacedName = uriExpression;
        if (uriExpression.contains("?")) {
            namespacedName = StringHelper.before(uriExpression, "?");
        }

        if (namespacedName.contains("/")) {
            return namespacedName.split("/", 2)[0];
        }

        return null;
    }

    public InputStream getResourceAsStream(String name) {
        InputStream is = null;
        if (classLoader != null) {
            is = classLoader.getResourceAsStream(name);
        }
        if (is == null) {
            is = DefaultCamelCatalog.class.getClassLoader().getResourceAsStream(name);
        }
        return is;
    }

    protected Message doNext() {
        if (parent == null) {
            parent = getNextElement();
        }
        Message answer = parent;
        parent = null;
        currentEntry = null;

        if (first && answer == null) {
            throw new IllegalStateException("Unable to unzip the file, it may be corrupted.");
        }

        first = false;
        checkNullAnswer(answer);

        return answer;
    }

        public void onFailure(final Exchange exchange) {
            if (shouldSkip(exchange, onCompleteOnly)) {
                return;
            }

             
            final Exchange copy = prepareExchange(exchange);
            final Exception original = copy.getException();
            if (original != null) {
                 
                 
                copy.setException(null);
            }

            if (executorService != null) {
                Runnable task = () -> {
                    LOG.debug("Processing onFailure: {}", copy);
                    doProcess(processor, copy);
                     
                    copy.setException(original);
                };
                task = prepareMDCParallelTask(camelContext, task);
                executorService.submit(task);
            } else {
                 
                LOG.debug("Processing onFailure: {}", copy);
                doProcess(processor, copy);
                 
                copy.setException(original);
            }
        }

    protected Configuration createConnectorConfiguration() {
        final Configuration.Builder configBuilder = Configuration.create();
        
        addPropertyIfNotNull(configBuilder, "transaction.metadata.factory", transactionMetadataFactory);
        addPropertyIfNotNull(configBuilder, "streaming.delay.ms", streamingDelayMs);
        addPropertyIfNotNull(configBuilder, "custom.metric.tags", customMetricTags);
        addPropertyIfNotNull(configBuilder, "mongodb.connection.string", mongodbConnectionString);
        addPropertyIfNotNull(configBuilder, "mongodb.password", mongodbPassword);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.namespace", openlineageIntegrationJobNamespace);
        addPropertyIfNotNull(configBuilder, "query.fetch.size", queryFetchSize);
        addPropertyIfNotNull(configBuilder, "signal.enabled.channels", signalEnabledChannels);
        addPropertyIfNotNull(configBuilder, "mongodb.ssl.enabled", mongodbSslEnabled);
        addPropertyIfNotNull(configBuilder, "cursor.max.await.time.ms", cursorMaxAwaitTimeMs);
        addPropertyIfNotNull(configBuilder, "field.renames", fieldRenames);
        addPropertyIfNotNull(configBuilder, "mongodb.server.selection.timeout.ms", mongodbServerSelectionTimeoutMs);
        addPropertyIfNotNull(configBuilder, "poll.interval.ms", pollIntervalMs);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.max", guardrailCollectionsMax);
        addPropertyIfNotNull(configBuilder, "signal.data.collection", signalDataCollection);
        addPropertyIfNotNull(configBuilder, "converters", converters);
        addPropertyIfNotNull(configBuilder, "heartbeat.topics.prefix", heartbeatTopicsPrefix);
        addPropertyIfNotNull(configBuilder, "mongodb.connect.timeout.ms", mongodbConnectTimeoutMs);
        addPropertyIfNotNull(configBuilder, "snapshot.fetch.size", snapshotFetchSize);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.tags", openlineageIntegrationJobTags);
        addPropertyIfNotNull(configBuilder, "mongodb.poll.interval.ms", mongodbPollIntervalMs);
        addPropertyIfNotNull(configBuilder, "incremental.snapshot.watermarking.strategy", incrementalSnapshotWatermarkingStrategy);
        addPropertyIfNotNull(configBuilder, "mongodb.user", mongodbUser);
        addPropertyIfNotNull(configBuilder, "heartbeat.interval.ms", heartbeatIntervalMs);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.schema.error", snapshotModeConfigurationBasedSnapshotOnSchemaError);
        addPropertyIfNotNull(configBuilder, "snapshot.collection.filter.overrides", snapshotCollectionFilterOverrides);
        addPropertyIfNotNull(configBuilder, "field.exclude.list", fieldExcludeList);
        addPropertyIfNotNull(configBuilder, "errors.max.retries", errorsMaxRetries);
        addPropertyIfNotNull(configBuilder, "database.exclude.list", databaseExcludeList);
        addPropertyIfNotNull(configBuilder, "max.batch.size", maxBatchSize);
        addPropertyIfNotNull(configBuilder, "skipped.operations", skippedOperations);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.description", openlineageIntegrationJobDescription);
        addPropertyIfNotNull(configBuilder, "topic.naming.strategy", topicNamingStrategy);
        addPropertyIfNotNull(configBuilder, "snapshot.mode", snapshotMode);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.data", snapshotModeConfigurationBasedSnapshotData);
        addPropertyIfNotNull(configBuilder, "extended.headers.enabled", extendedHeadersEnabled);
        addPropertyIfNotNull(configBuilder, "max.queue.size", maxQueueSize);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.limit.action", guardrailCollectionsLimitAction);
        addPropertyIfNotNull(configBuilder, "custom.sanitize.pattern", customSanitizePattern);
        addPropertyIfNotNull(configBuilder, "collection.include.list", collectionIncludeList);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.owners", openlineageIntegrationJobOwners);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.config.file.path", openlineageIntegrationConfigFilePath);
        addPropertyIfNotNull(configBuilder, "retriable.restart.connector.wait.ms", retriableRestartConnectorWaitMs);
        addPropertyIfNotNull(configBuilder, "capture.mode", captureMode);
        addPropertyIfNotNull(configBuilder, "snapshot.delay.ms", snapshotDelayMs);
        addPropertyIfNotNull(configBuilder, "executor.shutdown.timeout.ms", executorShutdownTimeoutMs);
        addPropertyIfNotNull(configBuilder, "provide.transaction.metadata", provideTransactionMetadata);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.data.error", snapshotModeConfigurationBasedSnapshotOnDataError);
        addPropertyIfNotNull(configBuilder, "schema.history.internal.file.filename", schemaHistoryInternalFileFilename);
        addPropertyIfNotNull(configBuilder, "tombstones.on.delete", tombstonesOnDelete);
        addPropertyIfNotNull(configBuilder, "topic.prefix", topicPrefix);
        addPropertyIfNotNull(configBuilder, "sourceinfo.struct.maker", sourceinfoStructMaker);
        addPropertyIfNotNull(configBuilder, "mongodb.authsource", mongodbAuthsource);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.dataset.kafka.bootstrap.servers", openlineageIntegrationDatasetKafkaBootstrapServers);
        addPropertyIfNotNull(configBuilder, "collection.exclude.list", collectionExcludeList);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.enabled", openlineageIntegrationEnabled);
        addPropertyIfNotNull(configBuilder, "snapshot.include.collection.list", snapshotIncludeCollectionList);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.start.stream", snapshotModeConfigurationBasedStartStream);
        addPropertyIfNotNull(configBuilder, "max.queue.size.in.bytes", maxQueueSizeInBytes);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.schema", snapshotModeConfigurationBasedSnapshotSchema);
        addPropertyIfNotNull(configBuilder, "signal.poll.interval.ms", signalPollIntervalMs);
        addPropertyIfNotNull(configBuilder, "post.processors", postProcessors);
        addPropertyIfNotNull(configBuilder, "notification.enabled.channels", notificationEnabledChannels);
        addPropertyIfNotNull(configBuilder, "mongodb.socket.timeout.ms", mongodbSocketTimeoutMs);
        addPropertyIfNotNull(configBuilder, "event.processing.failure.handling.mode", eventProcessingFailureHandlingMode);
        addPropertyIfNotNull(configBuilder, "snapshot.max.threads", snapshotMaxThreads);
        addPropertyIfNotNull(configBuilder, "notification.sink.topic.name", notificationSinkTopicName);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.custom.name", snapshotModeCustomName);
        addPropertyIfNotNull(configBuilder, "schema.name.adjustment.mode", schemaNameAdjustmentMode);
        addPropertyIfNotNull(configBuilder, "mongodb.ssl.invalid.hostname.allowed", mongodbSslInvalidHostnameAllowed);
        addPropertyIfNotNull(configBuilder, "mongodb.heartbeat.frequency.ms", mongodbHeartbeatFrequencyMs);
        addPropertyIfNotNull(configBuilder, "connection.validation.timeout.ms", connectionValidationTimeoutMs);
        addPropertyIfNotNull(configBuilder, "database.include.list", databaseIncludeList);
        
        return configBuilder.build();
    }

    public boolean process(Exchange exchange, AsyncCallback callback) {
        try {
             
            PooledExchangeTask task = taskFactory.acquire(exchange, callback);

            if (exchange.isTransacted()) {
                reactiveExecutor.scheduleQueue(task);
            } else {
                reactiveExecutor.scheduleMain(task);
            }
            return false;
        } catch (Exception e) {
            exchange.setException(e);
            callback.done(true);
            return true;
        }
    }

    public static AS2AsyncMDNServerConnection createAS2AsyncMDNServerConnection(AS2Configuration configuration)
            throws IOException {
        try {
            return asyncMdnServerConnections.computeIfAbsent(
                    configuration.getAsyncMdnPortNumber(),
                    key -> {
                        try {
                            return new AS2AsyncMDNServerConnection(
                                    configuration.getAsyncMdnPortNumber(), configuration.getSslContext());
                        } catch (IOException e) {
                            throw new UncheckedIOException(e);
                        }
                    });
        } catch (UncheckedIOException e) {
            throw e.getCause();
        }
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, jakarta.servlet.ServletInputStream.class, org.apache.camel.http.common.HttpMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.http.common.HttpConverter.toServletInputStream((org.apache.camel.http.common.HttpMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, jakarta.servlet.http.HttpServletRequest.class, org.apache.camel.Message.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.http.common.HttpConverter.toServletRequest((org.apache.camel.Message) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, jakarta.servlet.http.HttpServletResponse.class, org.apache.camel.Message.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.http.common.HttpConverter.toServletResponse((org.apache.camel.Message) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.io.BufferedReader.class, org.apache.camel.http.common.HttpMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.http.common.HttpConverter.toReader((org.apache.camel.http.common.HttpMessage) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.io.InputStream.class, jakarta.servlet.http.HttpServletRequest.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.http.common.HttpConverter.toInputStream((jakarta.servlet.http.HttpServletRequest) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.io.InputStream.class, org.apache.camel.http.common.HttpMessage.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.http.common.HttpConverter.toInputStream((org.apache.camel.http.common.HttpMessage) value, exchange);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

        public AnnotationBuilder withIsSecret(JsonNode node) {
            if (node == null) {
                return this;
            }
            if (node.isMissingNode()) {
                return this;
            }
            if (!node.isTextual()) {
                return this;
            }

            return withIsSecret(node.asBoolean());
        }

    private static ActiveMQMessage createActiveMQMessage(Exchange exchange) throws JMSException {
        Object body = exchange.getIn().getBody();
        if (body instanceof String) {
            ActiveMQTextMessage answer = new ActiveMQTextMessage();
            answer.setText((String) body);
            return answer;
        } else if (body instanceof Serializable) {
            ActiveMQObjectMessage answer = new ActiveMQObjectMessage();
            answer.setObject((Serializable) body);
            return answer;
        } else {
            return new ActiveMQMessage();
        }

    }

    protected void copyMavenWrapper() throws Exception {
        Path wrapperPath = Paths.get(BUILD_DIR, ".mvn/wrapper");
        Files.createDirectories(wrapperPath);
         
        Path mvnwPath = Paths.get(BUILD_DIR, "mvnw");
        Path mvnwCmdPath = Paths.get(BUILD_DIR, "mvnw.cmd");
        Path wrapperJarPath = wrapperPath.resolve("maven-wrapper.jar");
        Path wrapperPropsPath = wrapperPath.resolve("maven-wrapper.properties");

        try (InputStream is = ExportBaseCommand.class.getClassLoader().getResourceAsStream("maven-wrapper/mvnw")) {
            Files.copy(is, mvnwPath, StandardCopyOption.REPLACE_EXISTING);
        }
        try (InputStream is = ExportBaseCommand.class.getClassLoader().getResourceAsStream("maven-wrapper/mvnw.cmd")) {
            Files.copy(is, mvnwCmdPath, StandardCopyOption.REPLACE_EXISTING);
        }
        try (InputStream is = ExportBaseCommand.class.getClassLoader().getResourceAsStream("maven-wrapper/maven-wrapper.jar")) {
            Files.copy(is, wrapperJarPath, StandardCopyOption.REPLACE_EXISTING);
        }
        try (InputStream is
                = ExportBaseCommand.class.getClassLoader().getResourceAsStream("maven-wrapper/maven-wrapper.properties")) {
            Files.copy(is, wrapperPropsPath, StandardCopyOption.REPLACE_EXISTING);
        }

         
        FileUtil.setPosixFilePermissions(mvnwPath, "rwxr-xr-x");
        FileUtil.setPosixFilePermissions(mvnwCmdPath, "rwxr-xr-x");
    }

    public void onExchangeDone(Exchange exchange) {
         
         
         
        UnitOfWork uow = exchange.getUnitOfWork();
        if (uow != null) {
            int level = uow.routeStackLevel(registerTemplates, registerKamelets);
            if (level <= 1) {
                super.onExchangeDone(exchange);
            }
        } else {
            super.onExchangeDone(exchange);
        }
    }

        protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
            doBeforeParse(element);
            super.doParse(element, parserContext, builder);

             
            Binder<Node> binder;
            try {
                binder = getJaxbContext().createBinder();
            } catch (JAXBException e) {
                throw new BeanDefinitionStoreException("Failed to create the JAXB binder", e);
            }
            Object value = parseUsingJaxb(element, parserContext, binder);

            if (value instanceof CamelEndpointFactoryBean) {
                CamelEndpointFactoryBean factoryBean = (CamelEndpointFactoryBean) value;
                builder.addPropertyValue("properties", factoryBean.getProperties());
            }
        }

    private void doCreateOrUpdatePersistentVolumeClaim(
            Exchange exchange, String operationName,
            Function<Resource<PersistentVolumeClaim>, PersistentVolumeClaim> operation) {
        String pvcName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUME_CLAIM_NAME, String.class);
        String namespaceName = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        PersistentVolumeClaimSpec pvcSpec = exchange.getIn()
                .getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUME_CLAIM_SPEC, PersistentVolumeClaimSpec.class);
        if (ObjectHelper.isEmpty(pvcName)) {
            LOG.error("{} a specific Persistent Volume Claim require specify a Persistent Volume Claim name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Persistent Volume Claim require specify a Persistent Volume Claim name",
                            operationName));
        }
        if (ObjectHelper.isEmpty(namespaceName)) {
            LOG.error("{} a specific Persistent Volume Claim require specify a namespace name", operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Persistent Volume Claim require specify a namespace name", operationName));
        }
        if (ObjectHelper.isEmpty(pvcSpec)) {
            LOG.error("{} a specific Persistent Volume Claim require specify a Persistent Volume Claim spec bean",
                    operationName);
            throw new IllegalArgumentException(
                    String.format("%s a specific Persistent Volume Claim require specify a Persistent Volume Claim spec bean",
                            operationName));
        }
        Map<String, String> labels
                = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_PERSISTENT_VOLUMES_CLAIMS_LABELS, Map.class);
        PersistentVolumeClaim pvcCreating = new PersistentVolumeClaimBuilder().withNewMetadata().withName(pvcName)
                .withLabels(labels).endMetadata().withSpec(pvcSpec).build();
        PersistentVolumeClaim pvc
                = operation.apply(getEndpoint().getKubernetesClient().persistentVolumeClaims().inNamespace(namespaceName)
                        .resource(pvcCreating));

        prepareOutboundMessage(exchange, pvc);
    }

    private SslHandler configureClientSSLOnDemand() {
        if (!producer.getConfiguration().isSsl()) {
            return null;
        }

        if (producer.getConfiguration().getSslHandler() != null) {
            return producer.getConfiguration().getSslHandler();
        } else if (sslContext != null) {
            SSLEngine engine = sslContext.createSSLEngine();
            engine.setUseClientMode(true);
            if (producer.getConfiguration().isHostnameVerification()) {
                SSLParameters sslParams = engine.getSSLParameters();
                sslParams.setEndpointIdentificationAlgorithm("HTTPS");
                engine.setSSLParameters(sslParams);
            }
            if (producer.getConfiguration().getSslContextParameters() == null) {
                 
                engine.setEnabledProtocols(producer.getConfiguration().getEnabledProtocols().split(","));
            }
            return new SslHandler(engine);
        }

        return null;
    }

    protected boolean doHasNext() {
        try {
            if (zipInputStream == null) {
                return false;
            }
            boolean availableDataInCurrentEntry = currentEntry != null;
            if (!availableDataInCurrentEntry) {
                 
                parent = getNextElement();
                if (parent == null) {
                    zipInputStream.close();
                } else {
                    availableDataInCurrentEntry = true;
                }
            }
            return availableDataInCurrentEntry;
        } catch (IOException exception) {
            throw new RuntimeCamelException(exception);
        }
    }

    public static EventHubProducerAsyncClient createEventHubProducerAsyncClient(final EventHubsConfiguration configuration) {
        EventHubClientBuilder eventHubClientBuilder = new EventHubClientBuilder()
                .transportType(configuration.getAmqpTransportType())
                .retryOptions(configuration.getAmqpRetryOptions());

        CredentialType type = configuration.getCredentialType();
        if (type == null) {
            type = CredentialType.CONNECTION_STRING;
        }
        if (CredentialType.CONNECTION_STRING.equals(type)) {
            return eventHubClientBuilder
                    .connectionString(buildConnectionString(configuration))
                    .buildAsyncProducerClient();
        } else if (CredentialType.TOKEN_CREDENTIAL.equals(type)) {

            checkTokenCredentialConfiguration(configuration);
            return eventHubClientBuilder
                    .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                    .eventHubName(configuration.getEventHubName())
                    .credential(configuration.getTokenCredential())
                    .buildAsyncProducerClient();
        }
        return eventHubClientBuilder
                .fullyQualifiedNamespace(getFullyQualifiedNamespace(configuration))
                .eventHubName(configuration.getEventHubName())
                .credential(new DefaultAzureCredentialBuilder().build())
                .buildAsyncProducerClient();
    }

    private void setupLifecycleStrategy() {
        Map<String, LifecycleStrategy> lifecycleStrategies
                = getContext().getRegistry().findByTypeWithName(LifecycleStrategy.class);
        if (lifecycleStrategies != null && !lifecycleStrategies.isEmpty()) {
            for (Entry<String, LifecycleStrategy> entry : lifecycleStrategies.entrySet()) {
                LifecycleStrategy strategy = entry.getValue();
                 
                if (!getContext().getLifecycleStrategies().contains(strategy)) {
                    LOG.info("Using custom LifecycleStrategy with id: {} and implementation: {}", entry.getKey(), strategy);
                    getContext().addLifecycleStrategy(strategy);
                }
            }
        }
    }

    public PullRequestFilesProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_PULL_REQUEST_SERVICE);
        if (service != null) {
            LOG.debug("Using PullRequestService found in registry {}", service.getClass().getCanonicalName());
            pullRequestService = (PullRequestService) service;
        } else {
            pullRequestService = new PullRequestService();
        }
        initService(pullRequestService);
    }

    private static GenericFileExclusiveReadLockStrategy<FTPFile> getExclusiveReadLockStrategy(Map<String, Object> params) {
        GenericFileExclusiveReadLockStrategy<FTPFile> strategy
                = (GenericFileExclusiveReadLockStrategy<FTPFile>) params.get("exclusiveReadLockStrategy");
        if (strategy != null) {
            return strategy;
        }

         
        String readLock = (String) params.get("readLock");
        if (ObjectHelper.isNotEmpty(readLock)) {
            if ("none".equals(readLock) || "false".equals(readLock)) {
                return null;
            } else if ("rename".equals(readLock)) {
                GenericFileRenameExclusiveReadLockStrategy<FTPFile> readLockStrategy
                        = new GenericFileRenameExclusiveReadLockStrategy<>();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            } else if ("changed".equals(readLock)) {
                FtpChangedExclusiveReadLockStrategy readLockStrategy = new FtpChangedExclusiveReadLockStrategy();

                StrategyUtil.setup(readLockStrategy, params);

                return readLockStrategy;
            }
        }

        return null;
    }

    private void processGetQueryJob(Exchange exchange, AsyncCallback callback)
            throws SalesforceException {
        QueryJob job = exchange.getIn().getBody(QueryJob.class);
        String jobId;
        if (job != null) {
            jobId = job.getId();
        } else {
            jobId = getParameter(JOB_ID, exchange, USE_BODY, NOT_OPTIONAL);
        }
        bulkClient.getQueryJob(jobId, determineHeaders(exchange),
                new BulkApiV2Client.QueryJobResponseCallback() {
                    @Override
                    public void onResponse(QueryJob job, Map<String, String> headers, SalesforceException ex) {
                        processResponse(exchange, job, headers, ex, callback);
                    }
                });
    }

    private SSLContext provideSSLContext() throws GeneralSecurityException, IOException {
        if (sslContextParameters != null) {
            return sslContextParameters.createSSLContext(getCamelContext());
        } else if (getComponent().getSslContextParameters() != null) {
            return getComponent().getSslContextParameters().createSSLContext(getCamelContext());
        } else {
            return null;
        }
    }

    public int forceCompletionOfGroup(String key) {
         
        int total = 0;

        lock.lock();
        try {
            Exchange exchange = aggregationRepository.get(camelContext, key);
            if (exchange != null) {
                total = 1;
                LOG.trace("Force completion triggered for correlation key: {}", key);
                 
                exchange.setProperty(ExchangePropertyKey.AGGREGATED_COMPLETED_BY, COMPLETED_BY_FORCE);
                Exchange answer = onCompletion(key, exchange, exchange, false, false);
                if (answer != null) {
                    onSubmitCompletion(key, answer);
                }
            }
        } finally {
            lock.unlock();
        }
        LOG.trace("Completed force completion of group {}", key);

        if (total > 0) {
            LOG.debug("Forcing completion of group {} with {} exchanges", key, total);
        }
        return total;
    }

    protected static String jibMavenPluginVersion(Path settings, Properties prop) {
        String answer = null;
        if (prop != null) {
            answer = prop.getProperty(JIB_MAVEN_PLUGIN_VERSION);
        }
        if (answer == null) {
            try {
                List<String> lines = RuntimeUtil.loadPropertiesLines(settings);
                answer = lines.stream().filter(l -> l.startsWith(JIB_MAVEN_PLUGIN_VERSION + "="))
                        .map(s -> StringHelper.after(s, "=")).findFirst().orElse(null);
            } catch (Exception e) {
                 
            }
        }
        return answer != null ? answer : "3.4.5";
    }

    protected SubmitMulti createSubmitMultiTemplate(Exchange exchange) {
        Message in = exchange.getIn();
        SubmitMulti submitMulti = new SubmitMulti();

        if (in.getHeaders().containsKey(SmppConstants.DATA_CODING)) {
            submitMulti.setDataCoding(in.getHeader(SmppConstants.DATA_CODING, Byte.class));
        } else if (in.getHeaders().containsKey(SmppConstants.ALPHABET)) {
            submitMulti.setDataCoding(in.getHeader(SmppConstants.ALPHABET, Byte.class));
        } else {
            submitMulti.setDataCoding(config.getDataCoding());
        }

        byte destAddrTon;
        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR_TON)) {
            destAddrTon = in.getHeader(SmppConstants.DEST_ADDR_TON, Byte.class);
        } else {
            destAddrTon = config.getDestAddrTon();
        }

        byte destAddrNpi;
        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR_NPI)) {
            destAddrNpi = in.getHeader(SmppConstants.DEST_ADDR_NPI, Byte.class);
        } else {
            destAddrNpi = config.getDestAddrNpi();
        }

        List<String> destAddresses;
        if (in.getHeaders().containsKey(SmppConstants.DEST_ADDR)) {
            destAddresses = in.getHeader(SmppConstants.DEST_ADDR, List.class);
        } else {
            destAddresses = Arrays.asList(config.getDestAddr());
        }

        Address[] addresses = new Address[destAddresses.size()];
        int addrNum = 0;
        for (String destAddr : destAddresses) {
            Address addr = new Address(destAddrTon, destAddrNpi, destAddr);
            addresses[addrNum++] = addr;
        }
        submitMulti.setDestAddresses(addresses);

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR)) {
            submitMulti.setSourceAddr(in.getHeader(SmppConstants.SOURCE_ADDR, String.class));
        } else {
            submitMulti.setSourceAddr(config.getSourceAddr());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR_TON)) {
            submitMulti.setSourceAddrTon(in.getHeader(SmppConstants.SOURCE_ADDR_TON, Byte.class));
        } else {
            submitMulti.setSourceAddrTon(config.getSourceAddrTon());
        }

        if (in.getHeaders().containsKey(SmppConstants.SOURCE_ADDR_NPI)) {
            submitMulti.setSourceAddrNpi(in.getHeader(SmppConstants.SOURCE_ADDR_NPI, Byte.class));
        } else {
            submitMulti.setSourceAddrNpi(config.getSourceAddrNpi());
        }

        if (in.getHeaders().containsKey(SmppConstants.SERVICE_TYPE)) {
            submitMulti.setServiceType(in.getHeader(SmppConstants.SERVICE_TYPE, String.class));
        } else {
            submitMulti.setServiceType(config.getServiceType());
        }

        if (in.getHeaders().containsKey(SmppConstants.PROTOCOL_ID)) {
            submitMulti.setProtocolId(in.getHeader(SmppConstants.PROTOCOL_ID, Byte.class));
        } else {
            submitMulti.setProtocolId(config.getProtocolId());
        }

        if (in.getHeaders().containsKey(SmppConstants.PRIORITY_FLAG)) {
            submitMulti.setPriorityFlag(in.getHeader(SmppConstants.PRIORITY_FLAG, Byte.class));
        } else {
            submitMulti.setPriorityFlag(config.getPriorityFlag());
        }

        if (in.getHeaders().containsKey(SmppConstants.SCHEDULE_DELIVERY_TIME)) {
            submitMulti.setScheduleDeliveryTime(
                    SmppUtils.formatTime(in.getHeader(SmppConstants.SCHEDULE_DELIVERY_TIME, Date.class)));
        }

        if (in.getHeaders().containsKey(SmppConstants.VALIDITY_PERIOD)) {
            Object validityPeriod = in.getHeader(SmppConstants.VALIDITY_PERIOD);
            if (validityPeriod instanceof String) {
                submitMulti.setValidityPeriod((String) validityPeriod);
            } else if (validityPeriod instanceof Date) {
                submitMulti.setValidityPeriod(SmppUtils.formatTime((Date) validityPeriod));
            }
        }

        if (in.getHeaders().containsKey(SmppConstants.REPLACE_IF_PRESENT_FLAG)) {
            submitMulti.setReplaceIfPresentFlag(in.getHeader(SmppConstants.REPLACE_IF_PRESENT_FLAG, Byte.class));
        } else {
            submitMulti.setReplaceIfPresentFlag(config.getReplaceIfPresentFlag());
        }

        Map<java.lang.Short, Object> optinalParamater = in.getHeader(SmppConstants.OPTIONAL_PARAMETER, Map.class);
        if (optinalParamater != null) {
            List<OptionalParameter> optParams = createOptionalParametersByCode(optinalParamater);
            submitMulti.setOptionalParameters(optParams.toArray(new OptionalParameter[0]));
        } else {
            Map<String, String> optinalParamaters = in.getHeader(SmppConstants.OPTIONAL_PARAMETERS, Map.class);
            if (optinalParamaters != null) {
                List<OptionalParameter> optParams = createOptionalParametersByName(optinalParamaters);
                submitMulti.setOptionalParameters(optParams.toArray(new OptionalParameter[0]));
            } else {
                submitMulti.setOptionalParameters(new OptionalParameter[] {});
            }
        }

        return submitMulti;
    }

    private List<Row> parseTraceLine(Pid pid, String line) {
        JsonObject root = null;
        try {
            root = (JsonObject) Jsoner.deserialize(line);
        } catch (Exception e) {
             
        }
        if (root != null) {
            List<Row> rows = new ArrayList<>();
            JsonArray arr = root.getCollection("traces");
            if (arr != null) {
                for (Object o : arr) {
                    Row row = new Row(pid);
                    row.pid = pid.pid;
                    row.name = pid.name;
                    JsonObject jo = (JsonObject) o;
                    row.uid = jo.getLong("uid");
                    row.first = jo.getBoolean("first");
                    row.last = jo.getBoolean("last");
                    row.location = jo.getString("location");
                    row.routeId = jo.getString("routeId");
                    row.nodeId = jo.getString("nodeId");
                    if ("aggregate".equals(jo.getString("nodeShortName"))) {
                        row.aggregate = new JsonObject();
                        row.aggregate.put("nodeLabel", jo.getString("nodeLabel"));
                    }
                    String uri = jo.getString("endpointUri");
                    if (uri != null) {
                        row.endpoint = new JsonObject();
                        if (mask) {
                            uri = URISupport.sanitizeUri(uri);
                        }
                        row.endpoint.put("endpoint", uri);
                        row.endpoint.put("remote", jo.getBooleanOrDefault("remoteEndpoint", true));
                    }
                    JsonObject es = jo.getMap("endpointService");
                    if (es != null) {
                        row.endpointService = es;
                    }
                    Long ts = jo.getLong("timestamp");
                    if (ts != null) {
                        row.timestamp = ts;
                    }
                    row.elapsed = jo.getLong("elapsed");
                    row.failed = jo.getBoolean("failed");
                    row.done = jo.getBoolean("done");
                    row.threadName = jo.getString("threadName");
                    row.message = jo.getMap("message");
                    row.exception = jo.getMap("exception");
                    row.exchangeId = row.message.getString("exchangeId");
                    row.exchangePattern = row.message.getString("exchangePattern");
                     
                    row.message.remove("exchangeId");
                    row.message.remove("exchangePattern");
                    if (!showExchangeVariables) {
                        row.message.remove("exchangeVariables");
                    }
                    if (!showExchangeProperties) {
                        row.message.remove("exchangeProperties");
                    }
                    if (!showHeaders) {
                        row.message.remove("headers");
                    }
                    if (!showBody) {
                        row.message.remove("body");
                    }
                    if (!showException) {
                        row.exception = null;
                    }
                    rows.add(row);
                }
            }
            return rows;
        }
        return null;
    }

    public String browseMessageBody(Integer index) {
        List<Exchange> exchanges = getEndpoint().getExchanges();

        if (index >= exchanges.size()) {
            return null;
        }
        Exchange exchange = exchanges.get(index);
        if (exchange == null) {
            return null;
        }

        Message msg = exchange.getMessage();
        return MessageHelper.extractBodyAsString(msg);
    }

    protected Map<String, Object> doCallJson(Map<String, Object> options) {
        JsonObject root = new JsonObject();

        if (rr != null) {
            List<JsonObject> list = new ArrayList<>();
            root.put("rests", list);

            for (RestRegistry.RestService rs : rr.listAllRestServices()) {
                JsonObject jo = new JsonObject();
                jo.put("url", rs.getUrl());
                jo.put("method", rs.getMethod());
                jo.put("contractFirst", rs.isContractFirst());
                jo.put("state", rs.getState());
                if (rs.getConsumes() != null) {
                    jo.put("consumes", rs.getConsumes());
                }
                if (rs.getProduces() != null) {
                    jo.put("produces", rs.getProduces());
                }
                if (rs.getInType() != null) {
                    jo.put("inType", rs.getInType());
                }
                if (rs.getOutType() != null) {
                    jo.put("outType", rs.getOutType());
                }
                if (rs.getDescription() != null) {
                    jo.put("description", rs.getDescription());
                }
                list.add(jo);
            }
        }

        return root;
    }

    protected void doListConfigMapsByLabels(Exchange exchange) {
        String namespace = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_NAMESPACE_NAME, String.class);
        Map<String, String> labels = exchange.getIn().getHeader(KubernetesConstants.KUBERNETES_CONFIGMAPS_LABELS, Map.class);
        ConfigMapList configMapsList;

        if (ObjectHelper.isEmpty(labels)) {
            LOG.error("Listing ConfigMaps by labels requires specifying labels");
            throw new IllegalArgumentException("Listing ConfigMaps by labels requires specifying labels");
        }

        if (ObjectHelper.isEmpty(namespace)) {
            configMapsList = getEndpoint().getKubernetesClient().configMaps().inAnyNamespace().withLabels(labels).list();
        } else {
            configMapsList = getEndpoint().getKubernetesClient().configMaps().inNamespace(namespace).withLabels(labels).list();
        }

        prepareOutboundMessage(exchange, configMapsList.getItems());
    }

    private void registerConverters(TypeConverterRegistry registry) {
        addTypeConverter(registry, com.rometools.rome.feed.synd.SyndFeed.class, java.lang.String.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.xmlToFeed((java.lang.String) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
        addTypeConverter(registry, java.lang.String.class, com.rometools.rome.feed.synd.SyndFeed.class, false,
            (type, exchange, value) -> {
                Object answer = org.apache.camel.dataformat.rss.RssConverter.feedToXml((com.rometools.rome.feed.synd.SyndFeed) value);
                if (false && answer == null) {
                    answer = Void.class;
                }
                return answer;
            });
    }

            public void onResponse(InputStream response, Map<String, String> headers, SalesforceException ex) {
                JobInfo value = null;
                if (response != null) {
                    try {
                        value = unmarshalResponse(response, post, JobInfo.class);
                    } catch (SalesforceException e) {
                        ex = e;
                    }
                }
                callback.onResponse(value, headers, ex);
            }

    public Expression createExpression(CamelContext camelContext, String expression) {
        ObjectHelper.notNull(left, "left node", this);
        ObjectHelper.notNull(right, "right node", this);

        final Expression leftExp = left.createExpression(camelContext, expression);
        final Expression rightExp = right.createExpression(camelContext, expression);

        if (operator == LogicalOperatorType.AND) {
            return createAndExpression(leftExp, rightExp);
        } else if (operator == LogicalOperatorType.OR) {
            return createOrExpression(leftExp, rightExp);
        }

        throw new SimpleParserException("Unknown logical operator " + operator, token.getIndex());
    }

    static Map<String, List<String>> determineHeaders(final Exchange exchange) {
        final Message inboundMessage = exchange.getIn();

        final Map<String, Object> headers = inboundMessage.getHeaders();

        final Map<String, List<String>> answer = new HashMap<>();
        for (final String headerName : headers.keySet()) {
            final String headerNameLowercase = headerName.toLowerCase(Locale.US);
            if (headerNameLowercase.startsWith("sforce") || headerNameLowercase.startsWith("x-sfdc")) {
                final Object headerValue = inboundMessage.getHeader(headerName);

                if (headerValue instanceof String) {
                    answer.put(headerName, Collections.singletonList((String) headerValue));
                } else if (headerValue instanceof String[]) {
                    answer.put(headerName, Arrays.asList((String[]) headerValue));
                } else if (headerValue instanceof Collection) {
                    answer.put(headerName,
                            ((Collection<?>) headerValue).stream().map(String::valueOf).collect(Collectors.<String> toList()));
                } else {
                    throw new IllegalArgumentException(
                            "Given value for header `" + headerName + "`, is not String, String array or a Collection");
                }
            }
        }
        return answer;
    }

    protected void doInit() throws Exception {
        super.doInit();

        try {
            RestConfiguration config = CamelContextHelper.getRestConfiguration(getCamelContext(), "netty-http");

             
            if (config.getComponentProperties() != null && !config.getComponentProperties().isEmpty()) {
                setProperties(this, config.getComponentProperties());
            }
        } catch (IllegalArgumentException e) {
             
             
             
        }
    }

  static String add_escapes(String str) {
      StringBuilder retval = new StringBuilder();
      char ch;
      for (int i = 0; i < str.length(); i++) {
        switch (str.charAt(i))
        {
           case '\b':
              retval.append("\\b");
              continue;
           case '\t':
              retval.append("\\t");
              continue;
           case '\n':
              retval.append("\\n");
              continue;
           case '\f':
              retval.append("\\f");
              continue;
           case '\r':
              retval.append("\\r");
              continue;
           case '\"':
              retval.append("\\\"");
              continue;
           case '\'':
              retval.append("\\\'");
              continue;
           case '\\':
              retval.append("\\\\");
              continue;
           default:
              if ((ch = str.charAt(i)) < 0x20 || ch > 0x7e) {
                 String s = "0000" + Integer.toString(ch, 16);
                 retval.append("\\u" + s.substring(s.length() - 4, s.length()));
              } else {
                 retval.append(ch);
              }
              continue;
        }
      }
      return retval.toString();
   }

    public static void doWithClasses(Class<?> clazz, ClassCallback cc) throws IllegalArgumentException {
         
        Class<?>[] classes = clazz.getDeclaredClasses();
        for (Class<?> aClazz : classes) {
            try {
                cc.doWith(aClazz);
            } catch (IllegalAccessException ex) {
                throw new IllegalStateException("Shouldn't be illegal to access class '" + aClazz.getName() + "': " + ex);
            }
        }
    }

    public Short getShortOrDefault(final String key, final short defaultValue) {
        Object returnable;
        if (this.containsKey(key)) {
            returnable = this.get(key);
        } else {
            return defaultValue;
        }
        if (returnable == null) {
            return null;
        }
        if (returnable instanceof String) {
             
            returnable = new BigDecimal((String) returnable);
        }
        return ((Number) returnable).shortValue();
    }

    public void process(Exchange exchange) throws Exception {

        if (logger.isDebugEnabled()) {
             
             
             
            logger.debug("uploader thread/id: {} / {}. api call completed.", Thread.currentThread().getId(),
                    exchange.getExchangeId());
        }

        if (exchange.getIn().getBody() instanceof List) {
            boolean groupedExchanges = false;
            for (Object body : exchange.getIn().getBody(List.class)) {
                if (body instanceof Exchange) {
                    send((Exchange) body);
                    groupedExchanges = true;
                }
            }
            if (!groupedExchanges) {
                send(exchange);
            }
        } else {
            send(exchange);
        }
    }

    public static String getStringCarriageReturn(String returnCharacter) {
        if (returnCharacter.equals("WINDOWS")) {
            return CRLF;
        } else if (returnCharacter.equals("UNIX")) {
            return LINE_BREAK;
        } else if (returnCharacter.equals("MAC")) {
            return CARRIAGE_RETURN;
        } else {
            return returnCharacter;
        }
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        } else if (obj instanceof GenericArrayType) {
            return ((GenericArrayType) obj).getGenericComponentType().equals(componentType);
        } else {
            return false;
        }

    }

    private String getSecretFromSource(
            String key, String subkey, String defaultValue, String version)
            throws JsonProcessingException {

         
        secrets.add(key);

        String returnValue = null;
        try {
            SecretVersionName secretVersionName
                    = SecretVersionName.of(projectId, key, ObjectHelper.isNotEmpty(version) ? version : "latest");
            AccessSecretVersionResponse response = client.accessSecretVersion(secretVersionName);
            if (ObjectHelper.isNotEmpty(response)) {
                returnValue = response.getPayload().getData().toStringUtf8();
            }
            if (ObjectHelper.isNotEmpty(subkey) && ObjectHelper.isNotEmpty(returnValue)) {
                ObjectMapper mapper = new ObjectMapper();
                JsonNode actualObj = mapper.readTree(returnValue);
                JsonNode field = actualObj.get(subkey);
                if (ObjectHelper.isNotEmpty(field)) {
                    returnValue = field.textValue();
                } else {
                    returnValue = null;
                }
            }
            if (ObjectHelper.isEmpty(returnValue)) {
                returnValue = defaultValue;
            }
        } catch (ApiException ex) {
            if (ObjectHelper.isNotEmpty(defaultValue)) {
                returnValue = defaultValue;
            } else {
                throw ex;
            }
        }
        return returnValue;
    }

    private Function<Exchange, Object> deleteDocument() {
        return exchange -> {
            try {
                ArangoCollection collection = calculateDocumentCollection();

                boolean isMultiUpdate = exchange.getMessage().getHeader(MULTI_DELETE, false, Boolean.class);
                 
                if (isMultiUpdate) {
                    Collection<String> keysToDelete = exchange.getMessage().getMandatoryBody(Collection.class);
                    return collection.deleteDocuments(keysToDelete);
                }

                 
                String singleKey = exchange.getMessage().getMandatoryBody(String.class);
                return collection.deleteDocument(singleKey);
            } catch (InvalidPayloadException e) {
                throw new RuntimeCamelException(INVALID_PAYLOAD_MESSAGE, e);
            }
        };
    }

    public JobKey retrieveJobKey(Action action, ScheduledRouteDetails scheduledRouteDetails) {
        JobKey result = null;

        if (action == Action.START) {
            result = scheduledRouteDetails.getStartJobKey();
        } else if (action == Action.STOP) {
            result = scheduledRouteDetails.getStopJobKey();
        } else if (action == Action.SUSPEND) {
            result = scheduledRouteDetails.getSuspendJobKey();
        } else if (action == Action.RESUME) {
            result = scheduledRouteDetails.getResumeJobKey();
        }

        return result;
    }

    public Processor toProcessor(final MessageListener listener) {
        return new Processor() {
            public void process(Exchange exchange) throws Exception {
                Message message = toMessage(exchange);
                listener.onMessage(message);
            }

            @Override
            public String toString() {
                return "Processor of MessageListener: " + listener;
            }
        };
    }

    public PullRequestStateProducer(GitHubEndpoint endpoint) throws Exception {
        super(endpoint);

        Registry registry = endpoint.getCamelContext().getRegistry();
        Object service = registry.lookupByName(GitHubConstants.GITHUB_COMMIT_SERVICE);
        if (service != null) {
            LOG.debug("Using CommitService found in registry {}", service.getClass().getCanonicalName());
            commitService = (CommitService) service;
        } else {
            commitService = new CommitService();
        }
        initService(commitService);

        state = endpoint.getState();
        targetUrl = endpoint.getTargetUrl();
    }

    void ethNewFilter(Message message) throws IOException {
        DefaultBlockParameter fromBlock = toDefaultBlockParameter(
                message.getHeader(Web3jConstants.FROM_BLOCK, configuration::getFromBlock, String.class));
        DefaultBlockParameter toBlock
                = toDefaultBlockParameter(message.getHeader(Web3jConstants.TO_BLOCK, configuration::getToBlock, String.class));
        List<String> addresses = message.getHeader(Web3jConstants.ADDRESSES, configuration::getAddresses, List.class);
        List<String> topics = message.getHeader(Web3jConstants.TOPICS, configuration::getTopics, List.class);

        org.web3j.protocol.core.methods.request.EthFilter ethFilter
                = Web3jEndpoint.buildEthFilter(fromBlock, toBlock, addresses, topics);

        Request<?, EthFilter> request = web3j.ethNewFilter(ethFilter);
        setRequestId(message, request);
        EthFilter response = request.send();
        boolean hasError = checkForError(message, response);
        if (!hasError) {
            message.setBody(response.getFilterId());
        }
    }

    protected Configuration createConnectorConfiguration() {
        final Configuration.Builder configBuilder = Configuration.create();
        
        addPropertyIfNotNull(configBuilder, "snapshot.locking.mode", snapshotLockingMode);
        addPropertyIfNotNull(configBuilder, "message.key.columns", messageKeyColumns);
        addPropertyIfNotNull(configBuilder, "transaction.metadata.factory", transactionMetadataFactory);
        addPropertyIfNotNull(configBuilder, "custom.metric.tags", customMetricTags);
        addPropertyIfNotNull(configBuilder, "publication.name", publicationName);
        addPropertyIfNotNull(configBuilder, "signal.enabled.channels", signalEnabledChannels);
        addPropertyIfNotNull(configBuilder, "slot.max.retries", slotMaxRetries);
        addPropertyIfNotNull(configBuilder, "schema.refresh.mode", schemaRefreshMode);
        addPropertyIfNotNull(configBuilder, "database.sslmode", databaseSslmode);
        addPropertyIfNotNull(configBuilder, "signal.data.collection", signalDataCollection);
        addPropertyIfNotNull(configBuilder, "database.initial.statements", databaseInitialStatements);
        addPropertyIfNotNull(configBuilder, "converters", converters);
        addPropertyIfNotNull(configBuilder, "database.sslfactory", databaseSslfactory);
        addPropertyIfNotNull(configBuilder, "snapshot.fetch.size", snapshotFetchSize);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.tags", openlineageIntegrationJobTags);
        addPropertyIfNotNull(configBuilder, "snapshot.lock.timeout.ms", snapshotLockTimeoutMs);
        addPropertyIfNotNull(configBuilder, "database.dbname", databaseDbname);
        addPropertyIfNotNull(configBuilder, "database.sslkey", databaseSslkey);
        addPropertyIfNotNull(configBuilder, "snapshot.tables.order.by.row.count", snapshotTablesOrderByRowCount);
        addPropertyIfNotNull(configBuilder, "snapshot.select.statement.overrides", snapshotSelectStatementOverrides);
        addPropertyIfNotNull(configBuilder, "database.sslpassword", databaseSslpassword);
        addPropertyIfNotNull(configBuilder, "slot.failover", slotFailover);
        addPropertyIfNotNull(configBuilder, "table.exclude.list", tableExcludeList);
        addPropertyIfNotNull(configBuilder, "database.sslrootcert", databaseSslrootcert);
        addPropertyIfNotNull(configBuilder, "max.batch.size", maxBatchSize);
        addPropertyIfNotNull(configBuilder, "topic.naming.strategy", topicNamingStrategy);
        addPropertyIfNotNull(configBuilder, "snapshot.mode", snapshotMode);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.data", snapshotModeConfigurationBasedSnapshotData);
        addPropertyIfNotNull(configBuilder, "slot.name", slotName);
        addPropertyIfNotNull(configBuilder, "incremental.snapshot.chunk.size", incrementalSnapshotChunkSize);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.owners", openlineageIntegrationJobOwners);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.config.file.path", openlineageIntegrationConfigFilePath);
        addPropertyIfNotNull(configBuilder, "retriable.restart.connector.wait.ms", retriableRestartConnectorWaitMs);
        addPropertyIfNotNull(configBuilder, "snapshot.delay.ms", snapshotDelayMs);
        addPropertyIfNotNull(configBuilder, "executor.shutdown.timeout.ms", executorShutdownTimeoutMs);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.data.error", snapshotModeConfigurationBasedSnapshotOnDataError);
        addPropertyIfNotNull(configBuilder, "schema.history.internal.file.filename", schemaHistoryInternalFileFilename);
        addPropertyIfNotNull(configBuilder, "lsn.flush.mode", lsnFlushMode);
        addPropertyIfNotNull(configBuilder, "tombstones.on.delete", tombstonesOnDelete);
        addPropertyIfNotNull(configBuilder, "decimal.handling.mode", decimalHandlingMode);
        addPropertyIfNotNull(configBuilder, "binary.handling.mode", binaryHandlingMode);
        addPropertyIfNotNull(configBuilder, "snapshot.query.mode.custom.name", snapshotQueryModeCustomName);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.dataset.kafka.bootstrap.servers", openlineageIntegrationDatasetKafkaBootstrapServers);
        addPropertyIfNotNull(configBuilder, "table.ignore.builtin", tableIgnoreBuiltin);
        addPropertyIfNotNull(configBuilder, "schema.exclude.list", schemaExcludeList);
        addPropertyIfNotNull(configBuilder, "snapshot.include.collection.list", snapshotIncludeCollectionList);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.start.stream", snapshotModeConfigurationBasedStartStream);
        addPropertyIfNotNull(configBuilder, "slot.drop.on.stop", slotDropOnStop);
        addPropertyIfNotNull(configBuilder, "signal.poll.interval.ms", signalPollIntervalMs);
        addPropertyIfNotNull(configBuilder, "notification.enabled.channels", notificationEnabledChannels);
        addPropertyIfNotNull(configBuilder, "event.processing.failure.handling.mode", eventProcessingFailureHandlingMode);
        addPropertyIfNotNull(configBuilder, "snapshot.isolation.mode", snapshotIsolationMode);
        addPropertyIfNotNull(configBuilder, "snapshot.max.threads", snapshotMaxThreads);
        addPropertyIfNotNull(configBuilder, "notification.sink.topic.name", notificationSinkTopicName);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.custom.name", snapshotModeCustomName);
        addPropertyIfNotNull(configBuilder, "schema.name.adjustment.mode", schemaNameAdjustmentMode);
        addPropertyIfNotNull(configBuilder, "table.include.list", tableIncludeList);
        addPropertyIfNotNull(configBuilder, "slot.stream.params", slotStreamParams);
        addPropertyIfNotNull(configBuilder, "streaming.delay.ms", streamingDelayMs);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.namespace", openlineageIntegrationJobNamespace);
        addPropertyIfNotNull(configBuilder, "database.query.timeout.ms", databaseQueryTimeoutMs);
        addPropertyIfNotNull(configBuilder, "query.fetch.size", queryFetchSize);
        addPropertyIfNotNull(configBuilder, "schema.include.list", schemaIncludeList);
        addPropertyIfNotNull(configBuilder, "lsn.flush.timeout.ms", lsnFlushTimeoutMs);
        addPropertyIfNotNull(configBuilder, "unavailable.value.placeholder", unavailableValuePlaceholder);
        addPropertyIfNotNull(configBuilder, "heartbeat.action.query", heartbeatActionQuery);
        addPropertyIfNotNull(configBuilder, "replica.identity.autoset.values", replicaIdentityAutosetValues);
        addPropertyIfNotNull(configBuilder, "database.sslcert", databaseSslcert);
        addPropertyIfNotNull(configBuilder, "poll.interval.ms", pollIntervalMs);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.max", guardrailCollectionsMax);
        addPropertyIfNotNull(configBuilder, "interval.handling.mode", intervalHandlingMode);
        addPropertyIfNotNull(configBuilder, "heartbeat.topics.prefix", heartbeatTopicsPrefix);
        addPropertyIfNotNull(configBuilder, "status.update.interval.ms", statusUpdateIntervalMs);
        addPropertyIfNotNull(configBuilder, "database.user", databaseUser);
        addPropertyIfNotNull(configBuilder, "datatype.propagate.source.type", datatypePropagateSourceType);
        addPropertyIfNotNull(configBuilder, "incremental.snapshot.watermarking.strategy", incrementalSnapshotWatermarkingStrategy);
        addPropertyIfNotNull(configBuilder, "heartbeat.interval.ms", heartbeatIntervalMs);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.on.schema.error", snapshotModeConfigurationBasedSnapshotOnSchemaError);
        addPropertyIfNotNull(configBuilder, "column.include.list", columnIncludeList);
        addPropertyIfNotNull(configBuilder, "plugin.name", pluginName);
        addPropertyIfNotNull(configBuilder, "column.propagate.source.type", columnPropagateSourceType);
        addPropertyIfNotNull(configBuilder, "errors.max.retries", errorsMaxRetries);
        addPropertyIfNotNull(configBuilder, "database.password", databasePassword);
        addPropertyIfNotNull(configBuilder, "skipped.operations", skippedOperations);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.job.description", openlineageIntegrationJobDescription);
        addPropertyIfNotNull(configBuilder, "message.prefix.include.list", messagePrefixIncludeList);
        addPropertyIfNotNull(configBuilder, "extended.headers.enabled", extendedHeadersEnabled);
        addPropertyIfNotNull(configBuilder, "max.queue.size", maxQueueSize);
        addPropertyIfNotNull(configBuilder, "guardrail.collections.limit.action", guardrailCollectionsLimitAction);
        addPropertyIfNotNull(configBuilder, "custom.sanitize.pattern", customSanitizePattern);
        addPropertyIfNotNull(configBuilder, "hstore.handling.mode", hstoreHandlingMode);
        addPropertyIfNotNull(configBuilder, "snapshot.locking.mode.custom.name", snapshotLockingModeCustomName);
        addPropertyIfNotNull(configBuilder, "provide.transaction.metadata", provideTransactionMetadata);
        addPropertyIfNotNull(configBuilder, "snapshot.query.mode", snapshotQueryMode);
        addPropertyIfNotNull(configBuilder, "topic.prefix", topicPrefix);
        addPropertyIfNotNull(configBuilder, "slot.retry.delay.ms", slotRetryDelayMs);
        addPropertyIfNotNull(configBuilder, "include.schema.comments", includeSchemaComments);
        addPropertyIfNotNull(configBuilder, "sourceinfo.struct.maker", sourceinfoStructMaker);
        addPropertyIfNotNull(configBuilder, "openlineage.integration.enabled", openlineageIntegrationEnabled);
        addPropertyIfNotNull(configBuilder, "database.tcpKeepAlive", databaseTcpkeepalive);
        addPropertyIfNotNull(configBuilder, "publication.autocreate.mode", publicationAutocreateMode);
        addPropertyIfNotNull(configBuilder, "max.queue.size.in.bytes", maxQueueSizeInBytes);
        addPropertyIfNotNull(configBuilder, "publish.via.partition.root", publishViaPartitionRoot);
        addPropertyIfNotNull(configBuilder, "xmin.fetch.interval.ms", xminFetchIntervalMs);
        addPropertyIfNotNull(configBuilder, "snapshot.mode.configuration.based.snapshot.schema", snapshotModeConfigurationBasedSnapshotSchema);
        addPropertyIfNotNull(configBuilder, "time.precision.mode", timePrecisionMode);
        addPropertyIfNotNull(configBuilder, "message.prefix.exclude.list", messagePrefixExcludeList);
        addPropertyIfNotNull(configBuilder, "post.processors", postProcessors);
        addPropertyIfNotNull(configBuilder, "lsn.flush.timeout.action", lsnFlushTimeoutAction);
        addPropertyIfNotNull(configBuilder, "database.port", databasePort);
        addPropertyIfNotNull(configBuilder, "column.exclude.list", columnExcludeList);
        addPropertyIfNotNull(configBuilder, "include.unknown.datatypes", includeUnknownDatatypes);
        addPropertyIfNotNull(configBuilder, "database.hostname", databaseHostname);
        addPropertyIfNotNull(configBuilder, "connection.validation.timeout.ms", connectionValidationTimeoutMs);
        
        return configBuilder.build();
    }

    private void createClient(Keycloak keycloakClient, Exchange exchange) throws InvalidPayloadException {
        String realmName = exchange.getIn().getHeader(KeycloakConstants.REALM_NAME, String.class);
        if (ObjectHelper.isEmpty(realmName)) {
            throw new IllegalArgumentException(MISSING_REALM_NAME);
        }

        if (getConfiguration().isPojoRequest()) {
            Object payload = exchange.getIn().getMandatoryBody();
            if (payload instanceof ClientRepresentation) {
                Response response = keycloakClient.realm(realmName).clients().create((ClientRepresentation) payload);
                Message message = getMessageForResponse(exchange);
                message.setBody(response);
            }
        } else {
            ClientRepresentation client = new ClientRepresentation();
            if (ObjectHelper.isNotEmpty(exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID))) {
                String clientId = exchange.getIn().getHeader(KeycloakConstants.CLIENT_ID, String.class);
                client.setClientId(clientId);
                client.setEnabled(true);
            } else {
                throw new IllegalArgumentException(MISSING_CLIENT_ID);
            }
            Response response = keycloakClient.realm(realmName).clients().create(client);
            Message message = getMessageForResponse(exchange);
            message.setBody(response);
        }
    }

    private RestartContainerCmd executeRestartContainerRequest(DockerClient client, Message message) {

        LOGGER.debug("Executing Docker Restart Container Request");

        String containerId
                = DockerHelper.getProperty(DockerConstants.DOCKER_CONTAINER_ID, configuration, message, String.class);

        RestartContainerCmd restartContainerCmd = client.restartContainerCmd(containerId);

        Integer timeout = DockerHelper.getProperty(DockerConstants.DOCKER_TIMEOUT, configuration, message, Integer.class);

        if (timeout != null) {
            restartContainerCmd.withtTimeout(timeout);
        }

        return restartContainerCmd;

    }

    public void updateRouteConfigurationsToCamelContext(CamelContext context) throws Exception {
        setCamelContext(context);
        routeConfigurationCollection.setCamelContext(context);
        if (initializedConfiguration.compareAndSet(false, true)) {
            configuration();
        }
        List<RouteConfigurationDefinition> list = getRouteConfigurationCollection().getRouteConfigurations();
        if (!list.isEmpty()) {
             
            for (RouteConfigurationDefinition def : list) {
                context.getCamelContextExtension().getContextPlugin(Model.class)
                        .removeRouteConfiguration(def);
            }
            populateRoutesConfiguration();
        }
    }

    private static int getIndex(ParameterizedType type, TypeVariable<?> variable) {
        Type[] actualTypeArguments = type.getActualTypeArguments();
        for (int i = 0; i < actualTypeArguments.length; i++) {
            if (actualTypeArguments[i] instanceof TypeVariable) {
                TypeVariable<?> variableArgument = (TypeVariable<?>) actualTypeArguments[i];
                if (variableArgument.getName().equals(variable.getName())) {
                    return i;
                }
            }
        }
        return -1;
    }

    public void onUploadComplete(String host, String file) {
        String msg = "Uploading to host: " + host + " file: " + file + " completed";
        if (transferredBytes > 0) {
            msg += " (size: " + StringHelper.humanReadableBytes(transferredBytes) + ")";
        }
        long taken = watch.taken();
        String time = TimeUtils.printDuration(taken, true);
        msg += " (took: " + time + ")";
        doLog(msg);
    }

        public void calculateAndSetMaxConcurrentRequestsExpression(final Exchange exchange) throws Exception {
            lock.lock();
            try {
                Integer newThrottle = getMaximumRequestsExpression().evaluate(exchange, Integer.class);

                if (newThrottle != null && newThrottle < 0) {
                    throw new IllegalStateException(
                            "The maximumConcurrentRequests must be a positive number, was: " + newThrottle);
                }

                if (newThrottle == null && throttleRate == 0) {
                    throw new RuntimeExchangeException(
                            "The maxConcurrentRequestsExpression was evaluated as null: " + getMaximumRequestsExpression(),
                            exchange);
                }

                if (newThrottle != null) {
                    if (newThrottle != throttleRate) {
                         
                        if (throttleRate > newThrottle) {
                            int delta = throttleRate - newThrottle;

                             
                            semaphore.reducePermits(delta);
                            if (LOG.isDebugEnabled()) {
                                LOG.debug("Throttle rate decreased from {} to {}, triggered by ExchangeId: {}", throttleRate,
                                        newThrottle, exchange.getExchangeId());
                            }

                             
                        } else if (newThrottle > throttleRate) {
                            int delta = newThrottle - throttleRate;
                            semaphore.increasePermits(delta);
                            if (throttleRate == 0) {
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("Initial throttle rate set to {}, triggered by ExchangeId: {}", newThrottle,
                                            exchange.getExchangeId());
                                }
                            } else {
                                if (LOG.isDebugEnabled()) {
                                    LOG.debug("Throttle rate increase from {} to {}, triggered by ExchangeId: {}", throttleRate,
                                            newThrottle, exchange.getExchangeId());
                                }
                            }
                        }
                        throttleRate = newThrottle;
                    }
                }
            } finally {
                lock.unlock();
            }
        }